Example usage for org.apache.commons.cli OptionBuilder withLongOpt

List of usage examples for org.apache.commons.cli OptionBuilder withLongOpt

Introduction

In this page you can find the example usage for org.apache.commons.cli OptionBuilder withLongOpt.

Prototype

public static OptionBuilder withLongOpt(String newLongopt) 

Source Link

Document

The next Option created will have the following long option value.

Usage

From source file:com.seanmadden.fast.ldap.main.Main.java

/**
 * The Main Event.//from   ww w  . j a v  a 2  s.  co  m
 * 
 * @param args
 */
@SuppressWarnings("static-access")
public static void main(String[] args) {
    BasicConfigurator.configure();
    log.debug("System initializing");
    try {
        Logger.getRootLogger().addAppender(
                new FileAppender(new PatternLayout(PatternLayout.TTCC_CONVERSION_PATTERN), "log.log"));
    } catch (IOException e1) {
        log.error("Unable to open the log file..?");
    }

    /*
     * Initialize the configuration engine.
     */
    XMLConfiguration config = new XMLConfiguration();
    config.setListDelimiter('|');

    /*
     * Initialize the Command-Line parsing engine.
     */
    CommandLineParser parser = new PosixParser();
    Options opts = new Options();
    opts.addOption(OptionBuilder.withLongOpt("config-file").hasArg()
            .withDescription("The configuration file to load").withArgName("config.xml").create("c"));

    opts.addOption(OptionBuilder.withLongOpt("profile").hasArg().withDescription("The profile to use")
            .withArgName("Default").create("p"));

    opts.addOption(OptionBuilder.withLongOpt("password").hasArg().withDescription("Password to connect with")
            .withArgName("password").create("P"));

    opts.addOption(OptionBuilder.withLongOpt("debug").hasArg(false).create('d'));

    opts.addOption(OptionBuilder.withLongOpt("verbose").hasArg(false).create('v'));

    File configurationFile = new File("config.xml");

    try {
        // Parse the command-line options
        CommandLine cmds = parser.parse(opts, args);

        if (!cmds.hasOption('p')) {
            Logger.getRootLogger().addAppender(new GuiErrorAlerter(Level.ERROR));
        }

        Logger.getRootLogger().setLevel(Level.ERROR);
        if (cmds.hasOption('v')) {
            Logger.getRootLogger().setLevel(Level.INFO);
        }
        if (cmds.hasOption('d')) {
            Logger.getRootLogger().setLevel(Level.DEBUG);
        }

        log.debug("Enabling configuration file parsing");
        // The user has given us a file to parse.
        if (cmds.hasOption("c")) {
            configurationFile = new File(cmds.getOptionValue("c"));
        }
        log.debug("Config file: " + configurationFile);

        // Load the configuration file
        if (configurationFile.exists()) {
            config.load(configurationFile);
        } else {
            log.error("Cannot find config file");
        }

        /*
         * Convert the profiles into memory
         */
        Vector<ConnectionProfile> profs = new Vector<ConnectionProfile>();
        List<?> profList = config.configurationAt("Profiles").configurationsAt("Profile");
        for (Object p : profList) {
            SubnodeConfiguration profile = (SubnodeConfiguration) p;
            String name = profile.getString("[@name]");
            String auth = profile.getString("LdapAuthString");
            String server = profile.getString("LdapServerString");
            String group = profile.getString("LdapGroupsLocation");
            ConnectionProfile prof = new ConnectionProfile(name, server, auth, group);
            profs.add(prof);
        }
        ConnectionProfile prof = null;
        if (!cmds.hasOption('p')) {
            /*
             * Deploy the profile selector, to select a profile
             */
            ProfileSelector profSel = new ProfileSelector(profs);
            prof = profSel.getSelection();
            if (prof == null) {
                return;
            }
            /*
             * Empty the profiles and load a clean copy - then save it back
             * to the file
             */
            config.clearTree("Profiles");
            for (ConnectionProfile p : profSel.getProfiles()) {
                config.addProperty("Profiles.Profile(-1)[@name]", p.getName());
                config.addProperty("Profiles.Profile.LdapAuthString", p.getLdapAuthString());
                config.addProperty("Profiles.Profile.LdapServerString", p.getLdapServerString());
                config.addProperty("Profiles.Profile.LdapGroupsLocation", p.getLdapGroupsString());
            }
            config.save(configurationFile);
        } else {
            for (ConnectionProfile p : profs) {
                if (p.getName().equals(cmds.getOptionValue('p'))) {
                    prof = p;
                    break;
                }
            }
        }

        log.info("User selected " + prof);

        String password = "";
        if (cmds.hasOption('P')) {
            password = cmds.getOptionValue('P');
        } else {
            password = PasswordPrompter.promptForPassword("Password?");
        }

        if (password.equals("")) {
            return;
        }

        LdapInterface ldap = new LdapInterface(prof.getLdapServerString(), prof.getLdapAuthString(),
                prof.getLdapGroupsString(), password);

        /*
         * Gather options information from the configuration engine for the
         * specified report.
         */
        Hashtable<String, Hashtable<String, ReportOption>> reportDataStructure = new Hashtable<String, Hashtable<String, ReportOption>>();
        List<?> repConfig = config.configurationAt("Reports").configurationsAt("Report");
        for (Object p : repConfig) {
            SubnodeConfiguration repNode = (SubnodeConfiguration) p;

            // TODO Do something with the report profile.
            // Allowing the user to deploy "profiles" is a nice feature
            // String profile = repNode.getString("[@profile]");

            String reportName = repNode.getString("[@report]");
            Hashtable<String, ReportOption> reportOptions = new Hashtable<String, ReportOption>();
            reportDataStructure.put(reportName, reportOptions);
            // Loop through the options and add each to the table.
            for (Object o : repNode.configurationsAt("option")) {
                SubnodeConfiguration option = (SubnodeConfiguration) o;
                String name = option.getString("[@name]");
                String type = option.getString("[@type]");
                String value = option.getString("[@value]");

                ReportOption ro = new ReportOption();
                ro.setName(name);

                if (type.toLowerCase().equals("boolean")) {
                    ro.setBoolValue(Boolean.parseBoolean(value));
                } else if (type.toLowerCase().equals("integer")) {
                    ro.setIntValue(Integer.valueOf(value));
                } else {
                    // Assume a string type here then.
                    ro.setStrValue(value);
                }
                reportOptions.put(name, ro);
                log.debug(ro);
            }
        }
        System.out.println(reportDataStructure);

        /*
         * At this point, we now need to deploy the reports window to have
         * the user pick a report and select some happy options to allow
         * that report to work. Let's go.
         */
        /*
         * Deploy the Reports selector, to select a report
         */
        Reports.getInstance().setLdapConnection(ldap);
        ReportsWindow reports = new ReportsWindow(Reports.getInstance().getAllReports(), reportDataStructure);
        Report report = reports.getSelection();
        if (report == null) {
            return;
        }
        /*
         * Empty the profiles and load a clean copy - then save it back to
         * the file
         */
        config.clearTree("Reports");
        for (Report r : Reports.getInstance().getAllReports()) {
            config.addProperty("Reports.Report(-1)[@report]", r.getClass().getCanonicalName());
            config.addProperty("Reports.Report[@name]", "Standard");
            for (ReportOption ro : r.getOptions().values()) {
                config.addProperty("Reports.Report.option(-1)[@name]", ro.getName());
                config.addProperty("Reports.Report.option[@type]", ro.getType());
                config.addProperty("Reports.Report.option[@value]", ro.getStrValue());
            }
        }
        config.save(configurationFile);
        ProgressBar bar = new ProgressBar();
        bar.start();
        report.execute();
        ASCIIFormatter format = new ASCIIFormatter();
        ReportResult res = report.getResult();
        format.format(res, new File(res.getForName() + "_" + res.getReportName() + ".txt"));
        bar.stop();

        JOptionPane.showMessageDialog(null,
                "The report is at " + res.getForName() + "_" + res.getReportName() + ".txt", "Success",
                JOptionPane.INFORMATION_MESSAGE);

    } catch (ParseException e) {
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp("FAST Ldap Searcher", opts);
    } catch (ConfigurationException e) {
        e.printStackTrace();
        log.fatal("OH EM GEES!  Configuration errors.");
    } catch (Exception e) {
        e.printStackTrace();
    }

}

From source file:com.esri.geoevent.test.performance.ConsumerMain.java

/**
 * Main method - this is used to when running from command line
 *
 * @param args Command Line Parameters//from  ww  w.  ja va 2 s  .  co m
 */
@SuppressWarnings("static-access")
public static void main(String[] args) {

    // performer options
    Options performerOptions = new Options();
    performerOptions
            .addOption(OptionBuilder
                    .withLongOpt("type").withDescription("One of the following values: ["
                            + Protocol.getAllowableValues() + "]. (Default value is tcp).")
                    .hasArg().create("t"));
    performerOptions.addOption(OptionBuilder.withLongOpt("commandListenerPort").withDescription(
            "The TCP Port where consumer will listen for commands from the orchestrator. (Default value is 5010).")
            .hasArg().create("p"));
    performerOptions.addOption(OptionBuilder.withLongOpt("serverPort")
            .withDescription("The TCP Port where the server will listen for events. (Default value is 5675)")
            .hasArg().create("sp"));
    performerOptions.addOption("h", "help", false, "print the help message");

    // parse the command line
    CommandLineParser parser = new BasicParser();
    CommandLine cmd;

    // parse
    try {
        cmd = parser.parse(performerOptions, args, false);
    } catch (ParseException error) {
        printHelp(performerOptions);
        return;
    }

    // User requested Help 
    if (cmd.hasOption("h")) {
        printHelp(performerOptions);
        return;
    }

    if (cmd.getOptions().length == 0) {

        ConsumerUI ui = new ConsumerUI();
        ui.run();

    } else {
        // parse out the performer options
        String protocolValue = cmd.getOptionValue("t");
        String commandListenerPortValue = cmd.getOptionValue("p");

        if (protocolValue == null) {
            protocolValue = "tcp";
        }
        if (commandListenerPortValue == null) {
            commandListenerPortValue = "5020";
        }
        // validate
        if (!validateTestHarnessOptions(protocolValue, commandListenerPortValue)) {
            printHelp(performerOptions);
            return;
        }

        // parse the values
        Protocol protocol = Protocol.fromValue(protocolValue);
        boolean isLocal = "local".equalsIgnoreCase(commandListenerPortValue);
        int commandListenerPort = -1;
        if (!isLocal) {
            commandListenerPort = Integer.parseInt(commandListenerPortValue);
        }

        int serverPort = NumberUtils.toInt(cmd.getOptionValue("sp"), 5775);
        PerformanceCollector consumer;
        switch (protocol) {
        case TCP:
            consumer = new TcpEventConsumer();
            break;
        case TCP_SERVER:
            consumer = new TcpServerEventConsumer(serverPort);
            break;
        case WEBSOCKETS:
            consumer = new WebsocketEventConsumer();
            break;
        case WEBSOCKET_SERVER:
            consumer = new WebsocketServerEventConsumer(serverPort);
            break;
        case ACTIVE_MQ:
            consumer = new ActiveMQEventConsumer();
            break;
        case RABBIT_MQ:
            consumer = new RabbitMQEventConsumer();
            break;
        case STREAM_SERVICE:
            consumer = new StreamServiceEventConsumer();
            break;
        case KAFKA:
            consumer = new KafkaEventConsumer();
            break;
        case BDS:
            consumer = new BdsEventConsumer();
            break;
        case AZURE:
            consumer = new AzureIoTHubConsumer();
            break;
        default:
            return;
        }
        consumer.listenOnCommandPort((isLocal ? 5020 : commandListenerPort), true);

    }

}

From source file:edu.scripps.fl.pubchem.app.ResultDownloader.java

public static void main(String[] args) throws Exception {
    CommandLineHandler clh = new CommandLineHandler() {
        public void configureOptions(Options options) {
            options.addOption(OptionBuilder.withLongOpt("data_url").withType("").withValueSeparator('=')
                    .hasArg().create());
        }/*from  ww  w.  j a  v  a  2  s  .  c  o m*/
    };
    args = clh.handle(args);
    String data_url = clh.getCommandLine().getOptionValue("data_url");
    ResultDownloader rd = new ResultDownloader();

    if (data_url != null)
        rd.setDataUrl(new URL(data_url));
    else
        rd.setDataUrl(new URL("ftp://ftp.ncbi.nlm.nih.gov/pubchem/Bioassay/CSV/"));
    if (args.length == 0)
        rd.process();
    else {
        Integer[] list = (Integer[]) ConvertUtils.convert(args, Integer[].class);
        rd.process(((List<Integer>) Arrays.asList(list)).iterator());
    }
}

From source file:com.kappaware.logtrawler.Main.java

@SuppressWarnings("static-access")
static public void main(String[] argv) throws Throwable {

    Config config;/*from  w  w w  . ja  v a 2 s. com*/

    Options options = new Options();

    options.addOption(OptionBuilder.hasArg().withArgName("configFile").withLongOpt("config-file")
            .withDescription("JSON configuration file").create("c"));
    options.addOption(OptionBuilder.hasArg().withArgName("folder").withLongOpt("folder")
            .withDescription("Folder to monitor").create("f"));
    options.addOption(OptionBuilder.hasArg().withArgName("exclusion").withLongOpt("exclusion")
            .withDescription("Exclusion regex").create("x"));
    options.addOption(OptionBuilder.hasArg().withArgName("adminEndpoint").withLongOpt("admin-endpoint")
            .withDescription("Endpoint for admin REST").create("e"));
    options.addOption(OptionBuilder.hasArg().withArgName("outputFlow").withLongOpt("output-flow")
            .withDescription("Target to post result on").create("o"));
    options.addOption(OptionBuilder.hasArg().withArgName("hostname").withLongOpt("hostname")
            .withDescription("This hostname").create("h"));
    options.addOption(OptionBuilder.withLongOpt("displayDot").withDescription("Display Dot").create("d"));
    options.addOption(OptionBuilder.hasArg().withArgName("mimeType").withLongOpt("mime-type")
            .withDescription("Valid MIME type").create("m"));
    options.addOption(OptionBuilder.hasArg().withArgName("allowedAdmin").withLongOpt("allowedAdmin")
            .withDescription("Allowed admin network").create("a"));
    options.addOption(OptionBuilder.hasArg().withArgName("configFile").withLongOpt("gen-config-file")
            .withDescription("Generate JSON configuration file").create("g"));
    options.addOption(OptionBuilder.hasArg().withArgName("maxBatchSize").withLongOpt("max-batch-size")
            .withDescription("Max JSON batch (array) size").create("b"));

    CommandLineParser clParser = new BasicParser();
    CommandLine line;
    String configFile = null;
    try {
        // parse the command line argument
        line = clParser.parse(options, argv);
        if (line.hasOption("c")) {
            configFile = line.getOptionValue("c");
            config = Json.fromJson(Config.class,
                    new BufferedReader(new InputStreamReader(new FileInputStream(configFile))));
        } else {
            config = new Config();
        }
        if (line.hasOption("f")) {
            String[] fs = line.getOptionValues("f");
            // Get the first agent (Create it if needed)
            if (config.getAgents() == null || config.getAgents().size() == 0) {
                Config.Agent agent = new Config.Agent("default");
                config.addAgent(agent);
            }
            Config.Agent agent = config.getAgents().iterator().next();
            for (String f : fs) {
                agent.addFolder(new Config.Agent.Folder(f, false));
            }
        }
        if (line.hasOption("e")) {
            String e = line.getOptionValue("e");
            config.setAdminEndpoint(e);
        }
        if (line.hasOption("o")) {
            String[] es = line.getOptionValues("o");
            if (config.getAgents() != null) {
                for (Agent agent : config.getAgents()) {
                    for (String s : es) {
                        agent.addOuputFlow(s);
                    }
                }
            }
        }
        if (line.hasOption("h")) {
            String e = line.getOptionValue("h");
            config.setHostname(e);
        }
        if (line.hasOption("x")) {
            if (config.getAgents() != null) {
                for (Agent agent : config.getAgents()) {
                    if (agent.getFolders() != null) {
                        for (Folder folder : agent.getFolders()) {
                            String[] exs = line.getOptionValues("x");
                            for (String ex : exs) {
                                folder.addExcludedPath(ex);
                            }
                        }
                    }
                }
            }
        }
        if (line.hasOption("m")) {
            if (config.getAgents() != null) {
                for (Agent agent : config.getAgents()) {
                    String[] exs = line.getOptionValues("m");
                    for (String ex : exs) {
                        agent.addLogMimeType(ex);
                    }
                }
            }
        }
        if (line.hasOption("a")) {
            String[] exs = line.getOptionValues("a");
            for (String ex : exs) {
                config.addAdminAllowedNetwork(ex);
            }
        }
        if (line.hasOption("d")) {
            config.setDisplayDot(true);
        }
        if (line.hasOption("b")) {
            Integer i = getIntegerParameter(line, "b");
            if (config.getAgents() != null) {
                for (Agent agent : config.getAgents()) {
                    agent.setOutputMaxBatchSize(i);
                }
            }
        }
        config.setDefault();
        if (line.hasOption("g")) {
            String fileName = line.getOptionValue("g");
            PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(fileName, false)));
            out.println(Json.toJson(config, true));
            out.flush();
            out.close();
            System.exit(0);
        }
    } catch (ParseException exp) {
        // oops, something went wrong
        usage(options, exp.getMessage());
        return;
    }

    try {
        // Check config
        if (config.getAgents() == null || config.getAgents().size() < 1) {
            throw new ConfigurationException("At least one folder to monitor must be provided!");
        }
        Map<String, AgentHandler> agentHandlerByName = new HashMap<String, AgentHandler>();
        for (Config.Agent agent : config.getAgents()) {
            agentHandlerByName.put(agent.getName(), new AgentHandler(agent));
        }
        if (!Utils.isNullOrEmpty(config.getAdminEndpoint())) {
            new AdminServer(config, agentHandlerByName);
        }
    } catch (ConfigurationException e) {
        log.error(e.toString());
        System.exit(1);
    } catch (Throwable t) {
        log.error("Error in main", t);
        System.exit(2);
    }
}

From source file:com.esri.geoevent.test.performance.ProducerMain.java

/**
 * Main method - this is used to when running from command line
 *
 * @param args Command Line Options//from  www  .  j  av  a2  s. c  o m
 */
@SuppressWarnings("static-access")
public static void main(String[] args) {

    // performer options
    Options performerOptions = new Options();
    performerOptions
            .addOption(OptionBuilder
                    .withLongOpt("type").withDescription("One of the following values: ["
                            + Protocol.getAllowableValues() + "]. (Default value is tcp).")
                    .hasArg().create("t"));
    performerOptions.addOption(OptionBuilder.withLongOpt("commandListenerPort").withDescription(
            "The TCP Port where producer will listen for commands from the orchestrator. (Default value is 5020).")
            .hasArg().create("p"));
    performerOptions.addOption(OptionBuilder.withLongOpt("serverPort")
            .withDescription("The TCP Port where the server will produce events. (Default value is 5665)")
            .hasArg().create("sp"));
    performerOptions.addOption("h", "help", false, "print the help message");

    // parse the command line
    CommandLineParser parser = new BasicParser();
    CommandLine cmd = null;

    // parse
    try {
        cmd = parser.parse(performerOptions, args, false);
    } catch (ParseException error) {
        printHelp(performerOptions);
        return;
    }

    if (cmd.getOptions().length == 0) {
        // No Args Start GUI
        ProducerUI ui = new ProducerUI();
        ui.run();
    } else {
        // User Request Help Page
        if (cmd.hasOption("h")) {
            printHelp(performerOptions);
            return;
        }

        // parse out the performer options
        String protocolValue = cmd.getOptionValue("t");
        String commandListenerPortValue = cmd.getOptionValue("p");

        if (protocolValue == null) {
            protocolValue = "tcp";
        }
        if (commandListenerPortValue == null) {
            commandListenerPortValue = "5010";
        }

        // validate
        if (!validateTestHarnessOptions(protocolValue, commandListenerPortValue)) {
            printHelp(performerOptions);
            return;
        }

        // parse the values
        Protocol protocol = Protocol.fromValue(protocolValue);
        boolean isLocal = "local".equalsIgnoreCase(commandListenerPortValue);
        int commandListenerPort = -1;
        if (!isLocal) {
            commandListenerPort = Integer.parseInt(commandListenerPortValue);
        }

        int serverPort = NumberUtils.toInt(cmd.getOptionValue("sp"), 5665);
        PerformanceCollector producer = null;
        switch (protocol) {
        case TCP:
            producer = new TcpEventProducer();
            break;
        case TCP_SERVER:
            producer = new TcpServerEventProducer(serverPort);
            break;
        case WEBSOCKETS:
            producer = new WebsocketEventProducer();
            break;
        case ACTIVE_MQ:
            producer = new ActiveMQEventProducer();
            break;
        case RABBIT_MQ:
            producer = new RabbitMQEventProducer();
            break;
        case STREAM_SERVICE:
            producer = new StreamServiceEventProducer();
            break;
        case KAFKA:
            producer = new KafkaEventProducer();
            break;
        case WEBSOCKET_SERVER:
            producer = new WebsocketServerEventProducer(serverPort);
            break;
        case AZURE:
            producer = new AzureIoTHubProducer();
            break;
        case REST_JSON:
            producer = new JsonEventProducer();
            break;
        default:
            return;
        }
        producer.listenOnCommandPort((isLocal ? 5010 : commandListenerPort), true);

    }

}

From source file:jp.primecloud.auto.tool.management.main.Main.java

public static void main(String args[]) {
    Options options = new Options();
    options.addOption("Z", false, "Zabbix mode");
    options.addOption("U", false, "UPDATE mode");
    options.addOption("S", false, "SELECT mode");
    options.addOption("C", false, "Create Mode");
    options.addOption("P", false, "Show Platform");
    options.addOption("L", false, "Show Users");
    options.addOption("E", false, "Ecrypt UserPassword");
    options.addOption("I", false, "IaasGateway Mode");
    options.addOption("A", false, "PCC-API Genarate ID or Key Mode");
    options.addOption("W", false, "Decrypt UserPassword");

    options.addOption("username", true, "Create the username");
    options.addOption("password", true, "Create the password");
    options.addOption("firstname", true, "Create the firstname");
    options.addOption("familyname", true, "Create the familyname");
    options.addOption("userno", true, "Create the userno");

    options.addOption("dburl", "connectionurl", true, "PrimeCloud Controller database url");
    options.addOption("dbuser", "username", true, "PrimeCloud Controller database username");
    options.addOption("dbpass", "password", true, "PrimeCloud Controller database password");

    options.addOption("sql", true, "SQL");
    options.addOption("columnname", true, "columnName");
    options.addOption("columntype", true, "columnType");
    options.addOption("salt", true, "Salt");

    OptionBuilder.withLongOpt("prepared");
    OptionBuilder.hasArgs();//from  ww  w  . j  a v a 2 s  . co  m
    OptionBuilder.withDescription("execute as PreparedStatement");
    OptionBuilder.withArgName("params");
    Option optionPrepared = OptionBuilder.create();
    options.addOption(optionPrepared);

    // for Zabbix
    options.addOption("enable", false, "enable");
    options.addOption("disable", false, "disable");
    options.addOption("get", false, "getUser from zabbix");
    options.addOption("check", false, "API setting check for zabbix");

    options.addOption("config", true, "Property can obtain from management-config.properties");
    options.addOption("platformkind", true, "Platform kind. e.g. ec2 and ec2_vpc or vmware");
    options.addOption("platformname", true, "Platform can obtain from auto-config.xml");
    options.addOption("platformno", true, "Platform can obtain from auto-config.xml");

    // for IaasGateway(AWS, Cloudstack)
    options.addOption("keyname", true, "import your key pair as keyName");
    options.addOption("publickey", true, "import your public key");

    // for PCC
    options.addOption("accessid", true, "accessid for PCC-API");
    options.addOption("secretkey", true, "secretkey for PCC-API");
    options.addOption("generatetype", true, "genarateType for PCC-API");

    options.addOption("h", "help", false, "help");

    CommandLineParser parser = new BasicParser();

    CommandLine commandLine;
    try {
        commandLine = parser.parse(options, args);
    } catch (ParseException e) {
        System.out.println(
                "???????? -h?????????");
        return;
    }

    if (commandLine.hasOption("h")) {
        HelpFormatter f = new HelpFormatter();
        f.printHelp("PCC script ", options);
    }

    ManagementConfigLoader.init();
    //?

    //Zabbix?
    if (commandLine.hasOption("Z")) {
        if (commandLine.hasOption("C")) {
            //Zabbix?
            ZabbixMain.createExecute(commandLine);
        } else if (commandLine.hasOption("U")) {
            //Zabbix
            ZabbixMain.updateExecute(commandLine);
        } else if (commandLine.hasOption("disable")) {
            //Zabbix
            ZabbixMain.disableExecute(commandLine);
        } else if (commandLine.hasOption("enable")) {
            //Zabbix
            ZabbixMain.enableExecute(commandLine);
        } else if (commandLine.hasOption("get")) {
            //Zabbix?
            ZabbixMain.getUser(commandLine);
        } else if (commandLine.hasOption("check")) {
            //Zabbix??
            ZabbixMain.checkApiVersion();
        }
        //PCC?
    } else if (commandLine.hasOption("U")) {
        if (commandLine.hasOption("prepared")) {
            SQLMain.updateExecutePrepared(commandLine);
        } else {
            //Update?
            SQLMain.updateExecute(commandLine);
        }
    } else if (commandLine.hasOption("S")) {
        //Select?
        SQLMain.selectExecute(commandLine);
    } else if (commandLine.hasOption("P")) {
        //?
        ConfigMain.showPlatforms();
    } else if (commandLine.hasOption("L")) {
        //PCC?
        UserService.showUserPlatform();
    } else if (commandLine.hasOption("config")) {
        //???
        ConfigMain.getProperty(commandLine.getOptionValue("config"));
    } else if (commandLine.hasOption("platformname") && commandLine.hasOption("platformkind")) {
        //??????
        ConfigMain.getPlatformNo(commandLine.getOptionValue("platformname"),
                commandLine.getOptionValue("platformkind"));
    } else if (commandLine.hasOption("E")) {
        //PCC??
        UserService.encryptUserPassword(commandLine.getOptionValue("password"));
    } else if (commandLine.hasOption("I")) {
        //IaasGatewayCall??AWS or Cloudstack???
        IaasGatewayMain.importExecute(commandLine);
    } else if (commandLine.hasOption("A")) {
        PccApiGenerateService.genarate(commandLine);
    } else if (commandLine.hasOption("W")) {
        //PCC??
        UserService.decryptUserPassword(commandLine.getOptionValue("password"),
                commandLine.getOptionValue("salt"));
    }
}

From source file:com.entertailion.java.caster.Main.java

/**
 * @param args//from   www .  jav  a  2  s.  com
 */
public static void main(String[] args) {
    // http://commons.apache.org/proper/commons-cli/usage.html
    Option help = new Option("h", "help", false, "Print this help message");
    Option version = new Option("V", "version", false, "Print version information");
    Option list = new Option("l", "list", false, "List ChromeCast devices");
    Option verbose = new Option("v", "verbose", false, "Verbose debug logging");
    Option transcode = new Option("t", "transcode", false, "Transcode media; -f also required");
    Option rest = new Option("r", "rest", false, "REST API server");

    Option url = OptionBuilder.withLongOpt("stream").hasArg().withValueSeparator()
            .withDescription("HTTP URL for streaming content; -d also required").create("s");

    Option server = OptionBuilder.withLongOpt("device").hasArg().withValueSeparator()
            .withDescription("ChromeCast device IP address").create("d");

    Option id = OptionBuilder.withLongOpt("app-id").hasArg().withValueSeparator()
            .withDescription("App ID for whitelisted device").create("id");

    Option mediaFile = OptionBuilder.withLongOpt("file").hasArg().withValueSeparator()
            .withDescription("Local media file; -d also required").create("f");

    Option transcodingParameters = OptionBuilder.withLongOpt("transcode-parameters").hasArg()
            .withValueSeparator().withDescription("Transcode parameters; -t also required").create("tp");

    Option restPort = OptionBuilder.withLongOpt("rest-port").hasArg().withValueSeparator()
            .withDescription("REST API port; default 8080").create("rp");

    Options options = new Options();
    options.addOption(help);
    options.addOption(version);
    options.addOption(list);
    options.addOption(verbose);
    options.addOption(url);
    options.addOption(server);
    options.addOption(id);
    options.addOption(mediaFile);
    options.addOption(transcode);
    options.addOption(transcodingParameters);
    options.addOption(rest);
    options.addOption(restPort);
    // create the command line parser
    CommandLineParser parser = new PosixParser();

    //String[] arguments = new String[] { "-vr" };

    try {
        // parse the command line arguments
        CommandLine line = parser.parse(options, args);
        Option[] lineOptions = line.getOptions();
        if (lineOptions.length == 0) {
            System.out.println("caster: try 'java -jar caster.jar -h' for more information");
            System.exit(0);
        }

        Log.setVerbose(line.hasOption("v"));

        // Custom app-id
        if (line.hasOption("id")) {
            Log.d(LOG_TAG, line.getOptionValue("id"));
            appId = line.getOptionValue("id");
        }

        // Print version
        if (line.hasOption("V")) {
            System.out.println("Caster version " + VERSION);
        }

        // List ChromeCast devices
        if (line.hasOption("l")) {
            final DeviceFinder deviceFinder = new DeviceFinder(new DeviceFinderListener() {

                @Override
                public void discoveringDevices(DeviceFinder deviceFinder) {
                    Log.d(LOG_TAG, "discoveringDevices");
                }

                @Override
                public void discoveredDevices(DeviceFinder deviceFinder) {
                    Log.d(LOG_TAG, "discoveredDevices");
                    TrackedDialServers trackedDialServers = deviceFinder.getTrackedDialServers();
                    for (DialServer dialServer : trackedDialServers) {
                        System.out.println(dialServer.toString()); // keep system for output
                    }
                }

            });
            deviceFinder.discoverDevices();
        }

        // Stream media from internet
        if (line.hasOption("s") && line.hasOption("d")) {
            Log.d(LOG_TAG, line.getOptionValue("d"));
            Log.d(LOG_TAG, line.getOptionValue("s"));
            try {
                Playback playback = new Playback(platform, appId,
                        new DialServer(InetAddress.getByName(line.getOptionValue("d"))),
                        new PlaybackListener() {
                            private int time;
                            private int duration;
                            private int state;

                            @Override
                            public void updateTime(Playback playback, int time) {
                                Log.d(LOG_TAG, "updateTime: " + time);
                                this.time = time;
                            }

                            @Override
                            public void updateDuration(Playback playback, int duration) {
                                Log.d(LOG_TAG, "updateDuration: " + duration);
                                this.duration = duration;
                            }

                            @Override
                            public void updateState(Playback playback, int state) {
                                Log.d(LOG_TAG, "updateState: " + state);
                                // Stop the app if the video reaches the end
                                if (time > 0 && time == duration && state == 0) {
                                    playback.doStop();
                                    System.exit(0);
                                }
                            }

                            public int getTime() {
                                return time;
                            }

                            public int getDuration() {
                                return duration;
                            }

                            public int getState() {
                                return state;
                            }

                        });
                playback.stream(line.getOptionValue("s"));
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }

        // Play local media file
        if (line.hasOption("f") && line.hasOption("d")) {
            Log.d(LOG_TAG, line.getOptionValue("d"));
            Log.d(LOG_TAG, line.getOptionValue("f"));

            final String file = line.getOptionValue("f");
            String device = line.getOptionValue("d");

            try {
                Playback playback = new Playback(platform, appId, new DialServer(InetAddress.getByName(device)),
                        new PlaybackListener() {
                            private int time;
                            private int duration;
                            private int state;

                            @Override
                            public void updateTime(Playback playback, int time) {
                                Log.d(LOG_TAG, "updateTime: " + time);
                                this.time = time;
                            }

                            @Override
                            public void updateDuration(Playback playback, int duration) {
                                Log.d(LOG_TAG, "updateDuration: " + duration);
                                this.duration = duration;
                            }

                            @Override
                            public void updateState(Playback playback, int state) {
                                Log.d(LOG_TAG, "updateState: " + state);
                                // Stop the app if the video reaches the end
                                if (time > 0 && time == duration && state == 0) {
                                    playback.doStop();
                                    System.exit(0);
                                }
                            }

                            public int getTime() {
                                return time;
                            }

                            public int getDuration() {
                                return duration;
                            }

                            public int getState() {
                                return state;
                            }

                        });
                if (line.hasOption("t") && line.hasOption("tp")) {
                    playback.setTranscodingParameters(line.getOptionValue("tp"));
                }
                playback.play(file, line.hasOption("t"));
            } catch (Exception e) {
                e.printStackTrace();
                System.exit(1);
            }
        }

        // REST API server
        if (line.hasOption("r")) {
            final DeviceFinder deviceFinder = new DeviceFinder(new DeviceFinderListener() {

                @Override
                public void discoveringDevices(DeviceFinder deviceFinder) {
                    Log.d(LOG_TAG, "discoveringDevices");
                }

                @Override
                public void discoveredDevices(DeviceFinder deviceFinder) {
                    Log.d(LOG_TAG, "discoveredDevices");
                    TrackedDialServers trackedDialServers = deviceFinder.getTrackedDialServers();
                    for (DialServer dialServer : trackedDialServers) {
                        Log.d(LOG_TAG, dialServer.toString());
                    }
                }

            });
            deviceFinder.discoverDevices();

            int port = 0;
            if (line.hasOption("rp")) {
                try {
                    port = Integer.parseInt(line.getOptionValue("rp"));
                } catch (NumberFormatException e) {
                    Log.e(LOG_TAG, "invalid rest port", e);
                }
            }

            Playback.startWebserver(port, new WebListener() {
                String[] prefixes = { "/playback", "/devices" };
                HashMap<String, Playback> playbackMap = new HashMap<String, Playback>();
                HashMap<String, RestPlaybackListener> playbackListenerMap = new HashMap<String, RestPlaybackListener>();

                final class RestPlaybackListener implements PlaybackListener {
                    private String device;
                    private int time;
                    private int duration;
                    private int state;

                    public RestPlaybackListener(String device) {
                        this.device = device;
                    }

                    @Override
                    public void updateTime(Playback playback, int time) {
                        Log.d(LOG_TAG, "updateTime: " + time);
                        this.time = time;
                    }

                    @Override
                    public void updateDuration(Playback playback, int duration) {
                        Log.d(LOG_TAG, "updateDuration: " + duration);
                        this.duration = duration;
                    }

                    @Override
                    public void updateState(Playback playback, int state) {
                        Log.d(LOG_TAG, "updateState: " + state);
                        this.state = state;
                        // Stop the app if the video reaches the end
                        if (this.time > 0 && this.time == this.duration && state == 0) {
                            playback.doStop();
                            playbackMap.remove(device);
                            playbackListenerMap.remove(device);
                        }
                    }

                    public int getTime() {
                        return time;
                    }

                    public int getDuration() {
                        return duration;
                    }

                    public int getState() {
                        return state;
                    }

                }

                @Override
                public Response handleRequest(String uri, String method, Properties header, Properties parms) {
                    Log.d(LOG_TAG, "handleRequest: " + uri);

                    if (method.equals("GET")) {
                        if (uri.startsWith(prefixes[0])) { // playback
                            String device = parms.getProperty("device");
                            if (device != null) {
                                RestPlaybackListener playbackListener = playbackListenerMap.get(device);
                                if (playbackListener != null) {
                                    // https://code.google.com/p/json-simple/wiki/EncodingExamples
                                    JSONObject obj = new JSONObject();
                                    obj.put("time", playbackListener.getTime());
                                    obj.put("duration", playbackListener.getDuration());
                                    switch (playbackListener.getState()) {
                                    case 0:
                                        obj.put("state", "idle");
                                        break;
                                    case 1:
                                        obj.put("state", "stopped");
                                        break;
                                    case 2:
                                        obj.put("state", "playing");
                                        break;
                                    default:
                                        obj.put("state", "idle");
                                        break;
                                    }
                                    return new Response(HttpServer.HTTP_OK, "text/plain", obj.toJSONString());
                                } else {
                                    // Nothing is playing
                                    JSONObject obj = new JSONObject();
                                    obj.put("time", 0);
                                    obj.put("duration", 0);
                                    obj.put("state", "stopped");
                                    return new Response(HttpServer.HTTP_OK, "text/plain", obj.toJSONString());
                                }
                            }
                        } else if (uri.startsWith(prefixes[1])) { // devices
                            // https://code.google.com/p/json-simple/wiki/EncodingExamples
                            JSONArray list = new JSONArray();
                            TrackedDialServers trackedDialServers = deviceFinder.getTrackedDialServers();
                            for (DialServer dialServer : trackedDialServers) {
                                JSONObject obj = new JSONObject();
                                obj.put("name", dialServer.getFriendlyName());
                                obj.put("ip_address", dialServer.getIpAddress().getHostAddress());
                                list.add(obj);
                            }
                            return new Response(HttpServer.HTTP_OK, "text/plain", list.toJSONString());
                        }
                    } else if (method.equals("POST")) {
                        if (uri.startsWith(prefixes[0])) { // playback
                            String device = parms.getProperty("device");
                            if (device != null) {
                                String stream = parms.getProperty("stream");
                                String file = parms.getProperty("file");
                                String state = parms.getProperty("state");
                                String transcode = parms.getProperty("transcode");
                                String transcodeParameters = parms.getProperty("transcode-parameters");
                                Log.d(LOG_TAG, "transcodeParameters=" + transcodeParameters);
                                if (stream != null) {
                                    try {
                                        if (playbackMap.get(device) == null) {
                                            DialServer dialServer = deviceFinder.getTrackedDialServers()
                                                    .findDialServer(InetAddress.getByName(device));
                                            if (dialServer != null) {
                                                RestPlaybackListener playbackListener = new RestPlaybackListener(
                                                        device);
                                                playbackMap.put(device, new Playback(platform, appId,
                                                        dialServer, playbackListener));
                                                playbackListenerMap.put(device, playbackListener);
                                            }
                                        }
                                        Playback playback = playbackMap.get(device);
                                        if (playback != null) {
                                            playback.stream(stream);
                                            return new Response(HttpServer.HTTP_OK, "text/plain", "Ok");
                                        }
                                    } catch (Exception e1) {
                                        Log.e(LOG_TAG, "playback", e1);
                                    }
                                } else if (file != null) {
                                    try {
                                        if (playbackMap.get(device) == null) {
                                            DialServer dialServer = deviceFinder.getTrackedDialServers()
                                                    .findDialServer(InetAddress.getByName(device));
                                            if (dialServer != null) {
                                                RestPlaybackListener playbackListener = new RestPlaybackListener(
                                                        device);
                                                playbackMap.put(device, new Playback(platform, appId,
                                                        dialServer, playbackListener));
                                                playbackListenerMap.put(device, playbackListener);
                                            }
                                        }
                                        Playback playback = playbackMap.get(device);
                                        if (transcodeParameters != null) {
                                            playback.setTranscodingParameters(transcodeParameters);
                                        }
                                        if (playback != null) {
                                            playback.play(file, transcode != null);
                                            return new Response(HttpServer.HTTP_OK, "text/plain", "Ok");
                                        }
                                    } catch (Exception e1) {
                                        Log.e(LOG_TAG, "playback", e1);
                                    }
                                } else if (state != null) {
                                    try {
                                        if (playbackMap.get(device) == null) {
                                            DialServer dialServer = deviceFinder.getTrackedDialServers()
                                                    .findDialServer(InetAddress.getByName(device));
                                            if (dialServer != null) {
                                                RestPlaybackListener playbackListener = new RestPlaybackListener(
                                                        device);
                                                playbackMap.put(device, new Playback(platform, appId,
                                                        dialServer, playbackListener));
                                                playbackListenerMap.put(device, playbackListener);
                                            }
                                        }
                                        Playback playback = playbackMap.get(device);
                                        if (playback != null) {
                                            // Handle case where current app wasn't started with caster
                                            playback.setDialServer(deviceFinder.getTrackedDialServers()
                                                    .findDialServer(InetAddress.getByName(device)));
                                            // Change the playback state
                                            if (state.equals("play")) {
                                                playback.doPlay();
                                                return new Response(HttpServer.HTTP_OK, "text/plain", "Ok");
                                            } else if (state.equals("pause")) {
                                                playback.doPause();
                                                return new Response(HttpServer.HTTP_OK, "text/plain", "Ok");
                                            } else if (state.equals("stop")) {
                                                playback.doStop();
                                                playbackMap.remove(device);
                                                playbackListenerMap.remove(device);
                                                return new Response(HttpServer.HTTP_OK, "text/plain", "Ok");
                                            } else {
                                                Log.e(LOG_TAG, "playback invalid state: " + state);
                                            }
                                        }
                                    } catch (Exception e1) {
                                        Log.e(LOG_TAG, "playback", e1);
                                    }
                                }
                            }
                        }
                    }

                    return new Response(HttpServer.HTTP_BADREQUEST, "text/plain", "Bad Request");
                }

                @Override
                public String[] uriPrefixes() {
                    return prefixes;
                }

            });
            Log.d(LOG_TAG, "REST server ready");

            // Run forever...
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                }
            }
        }

        // Print help
        if (line.hasOption("h")) {
            printHelp(options);
        }
    } catch (ParseException exp) {
        System.out.println("ERROR: " + exp.getMessage());
        System.out.println();
        printHelp(options);
    }
}

From source file:apps.quantification.LearnQuantificationSVMLight.java

public static void main(String[] args) throws IOException {
    String cmdLineSyntax = LearnQuantificationSVMLight.class.getName()
            + " [OPTIONS] <path to svm_light_learn> <path to svm_light_classify> <trainingIndexDirectory> <outputDirectory>";

    Options options = new Options();

    OptionBuilder.withArgName("f");
    OptionBuilder.withDescription("Number of folds");
    OptionBuilder.withLongOpt("f");
    OptionBuilder.isRequired(true);// ww w  .  j a v a  2  s. c om
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("c");
    OptionBuilder.withDescription("The c value for svm_light (default 1)");
    OptionBuilder.withLongOpt("c");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("k");
    OptionBuilder.withDescription("Kernel type (default 0: linear, 1: polynomial, 2: RBF, 3: sigmoid)");
    OptionBuilder.withLongOpt("k");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("t");
    OptionBuilder.withDescription("Path for temporary files");
    OptionBuilder.withLongOpt("t");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("v");
    OptionBuilder.withDescription("Verbose output");
    OptionBuilder.withLongOpt("v");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg(false);
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("s");
    OptionBuilder.withDescription("Don't delete temporary training file in svm_light format (default: delete)");
    OptionBuilder.withLongOpt("s");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg(false);
    options.addOption(OptionBuilder.create());

    SvmLightLearnerCustomizer classificationLearnerCustomizer = null;
    SvmLightClassifierCustomizer classificationCustomizer = null;

    int folds = -1;

    GnuParser parser = new GnuParser();
    String[] remainingArgs = null;
    try {
        CommandLine line = parser.parse(options, args);

        remainingArgs = line.getArgs();

        classificationLearnerCustomizer = new SvmLightLearnerCustomizer(remainingArgs[0]);
        classificationCustomizer = new SvmLightClassifierCustomizer(remainingArgs[1]);

        folds = Integer.parseInt(line.getOptionValue("f"));

        if (line.hasOption("c"))
            classificationLearnerCustomizer.setC(Float.parseFloat(line.getOptionValue("c")));

        if (line.hasOption("k")) {
            System.out.println("Kernel type: " + line.getOptionValue("k"));
            classificationLearnerCustomizer.setKernelType(Integer.parseInt(line.getOptionValue("k")));
        }

        if (line.hasOption("v"))
            classificationLearnerCustomizer.printSvmLightOutput(true);

        if (line.hasOption("s"))
            classificationLearnerCustomizer.setDeleteTrainingFiles(false);

        if (line.hasOption("t")) {
            classificationLearnerCustomizer.setTempPath(line.getOptionValue("t"));
            classificationCustomizer.setTempPath(line.getOptionValue("t"));
        }

    } catch (Exception exp) {
        System.err.println("Parsing failed.  Reason: " + exp.getMessage());
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(cmdLineSyntax, options);
        System.exit(-1);
    }

    assert (classificationLearnerCustomizer != null);

    if (remainingArgs.length != 4) {
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(cmdLineSyntax, options);
        System.exit(-1);
    }

    String indexFile = remainingArgs[2];

    File file = new File(indexFile);

    String indexName = file.getName();
    String indexPath = file.getParent();

    String outputPath = remainingArgs[3];

    SvmLightLearner classificationLearner = new SvmLightLearner();

    classificationLearner.setRuntimeCustomizer(classificationLearnerCustomizer);

    FileSystemStorageManager fssm = new FileSystemStorageManager(indexPath, false);
    fssm.open();

    IIndex training = TroveReadWriteHelper.readIndex(fssm, indexName, TroveContentDBType.Full,
            TroveClassificationDBType.Full);

    final TextualProgressBar progressBar = new TextualProgressBar("Learning the quantifiers");

    IOperationStatusListener status = new IOperationStatusListener() {

        @Override
        public void operationStatus(double percentage) {
            progressBar.signal((int) percentage);
        }
    };

    QuantificationLearner quantificationLearner = new QuantificationLearner(folds, classificationLearner,
            classificationLearnerCustomizer, classificationCustomizer, ClassificationMode.PER_CATEGORY,
            new LogisticFunction(), status);

    IQuantifier[] quantifiers = quantificationLearner.learn(training);

    File executableFile = new File(classificationLearnerCustomizer.getSvmLightLearnPath());
    IDataManager classifierDataManager = new SvmLightDataManager(new SvmLightClassifierCustomizer(
            executableFile.getParentFile().getAbsolutePath() + Os.pathSeparator() + "svm_light_classify"));
    String description = "_SVMLight_C-" + classificationLearnerCustomizer.getC() + "_K-"
            + classificationLearnerCustomizer.getKernelType();
    if (classificationLearnerCustomizer.getAdditionalParameters().length() > 0)
        description += "_" + classificationLearnerCustomizer.getAdditionalParameters();
    String quantifierPrefix = indexName + "_Quantifier-" + folds + description;

    FileSystemStorageManager fssmo = new FileSystemStorageManager(
            outputPath + File.separatorChar + quantifierPrefix, true);
    fssmo.open();
    QuantificationLearner.write(quantifiers, fssmo, classifierDataManager);
    fssmo.close();

    BufferedWriter bfs = new BufferedWriter(
            new FileWriter(outputPath + File.separatorChar + quantifierPrefix + "_rates.txt"));
    TShortDoubleHashMap simpleTPRs = quantificationLearner.getSimpleTPRs();
    TShortDoubleHashMap simpleFPRs = quantificationLearner.getSimpleFPRs();
    TShortDoubleHashMap scaledTPRs = quantificationLearner.getScaledTPRs();
    TShortDoubleHashMap scaledFPRs = quantificationLearner.getScaledFPRs();

    ContingencyTableSet contingencyTableSet = quantificationLearner.getContingencyTableSet();

    short[] cats = simpleTPRs.keys();
    for (int i = 0; i < cats.length; ++i) {
        short cat = cats[i];
        String catName = training.getCategoryDB().getCategoryName(cat);
        ContingencyTable contingencyTable = contingencyTableSet.getCategoryContingencyTable(cat);
        double simpleTPR = simpleTPRs.get(cat);
        double simpleFPR = simpleFPRs.get(cat);
        double scaledTPR = scaledTPRs.get(cat);
        double scaledFPR = scaledFPRs.get(cat);
        String line = quantifierPrefix + "\ttrain\tsimple\t" + catName + "\t" + cat + "\t"
                + contingencyTable.tp() + "\t" + contingencyTable.fp() + "\t" + contingencyTable.fn() + "\t"
                + contingencyTable.tn() + "\t" + simpleTPR + "\t" + simpleFPR + "\n";
        bfs.write(line);
        line = quantifierPrefix + "\ttrain\tscaled\t" + catName + "\t" + cat + "\t" + contingencyTable.tp()
                + "\t" + contingencyTable.fp() + "\t" + contingencyTable.fn() + "\t" + contingencyTable.tn()
                + "\t" + scaledTPR + "\t" + scaledFPR + "\n";
        bfs.write(line);
    }
    bfs.close();
}

From source file:apps.quantification.LearnQuantificationSVMPerf.java

public static void main(String[] args) throws IOException {
    String cmdLineSyntax = LearnQuantificationSVMPerf.class.getName()
            + " [OPTIONS] <path to svm_perf_learn> <path to svm_perf_classify> <trainingIndexDirectory> <outputDirectory>";

    Options options = new Options();

    OptionBuilder.withArgName("f");
    OptionBuilder.withDescription("Number of folds");
    OptionBuilder.withLongOpt("f");
    OptionBuilder.isRequired(true);/*from  w  w  w.  j a  v  a2s. c om*/
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("c");
    OptionBuilder.withDescription("The c value for svm_perf (default 0.01)");
    OptionBuilder.withLongOpt("c");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("t");
    OptionBuilder.withDescription("Path for temporary files");
    OptionBuilder.withLongOpt("t");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("l");
    OptionBuilder.withDescription("The loss function to optimize (default 2):\n"
            + "               0  Zero/one loss: 1 if vector of predictions contains error, 0 otherwise.\n"
            + "               1  F1: 100 minus the F1-score in percent.\n"
            + "               2  Errorrate: Percentage of errors in prediction vector.\n"
            + "               3  Prec/Rec Breakeven: 100 minus PRBEP in percent.\n"
            + "               4  Prec@p: 100 minus precision at p in percent.\n"
            + "               5  Rec@p: 100 minus recall at p in percent.\n"
            + "               10  ROCArea: Percentage of swapped pos/neg pairs (i.e. 100 - ROCArea).");
    OptionBuilder.withLongOpt("l");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("w");
    OptionBuilder.withDescription("Choice of structural learning algorithm (default 9):\n"
            + "               0: n-slack algorithm described in [2]\n"
            + "               1: n-slack algorithm with shrinking heuristic\n"
            + "               2: 1-slack algorithm (primal) described in [5]\n"
            + "               3: 1-slack algorithm (dual) described in [5]\n"
            + "               4: 1-slack algorithm (dual) with constraint cache [5]\n"
            + "               9: custom algorithm in svm_struct_learn_custom.c");
    OptionBuilder.withLongOpt("w");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("p");
    OptionBuilder.withDescription("The value of p used by the prec@p and rec@p loss functions (default 0)");
    OptionBuilder.withLongOpt("p");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg();
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("v");
    OptionBuilder.withDescription("Verbose output");
    OptionBuilder.withLongOpt("v");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg(false);
    options.addOption(OptionBuilder.create());

    OptionBuilder.withArgName("s");
    OptionBuilder.withDescription("Don't delete temporary training file in svm_perf format (default: delete)");
    OptionBuilder.withLongOpt("s");
    OptionBuilder.isRequired(false);
    OptionBuilder.hasArg(false);
    options.addOption(OptionBuilder.create());

    SvmPerfLearnerCustomizer classificationLearnerCustomizer = null;
    SvmPerfClassifierCustomizer classificationCustomizer = null;

    int folds = -1;

    GnuParser parser = new GnuParser();
    String[] remainingArgs = null;
    try {
        CommandLine line = parser.parse(options, args);

        remainingArgs = line.getArgs();

        classificationLearnerCustomizer = new SvmPerfLearnerCustomizer(remainingArgs[0]);
        classificationCustomizer = new SvmPerfClassifierCustomizer(remainingArgs[1]);

        folds = Integer.parseInt(line.getOptionValue("f"));

        if (line.hasOption("c"))
            classificationLearnerCustomizer.setC(Float.parseFloat(line.getOptionValue("c")));

        if (line.hasOption("w"))
            classificationLearnerCustomizer.setW(Integer.parseInt(line.getOptionValue("w")));

        if (line.hasOption("p"))
            classificationLearnerCustomizer.setP(Integer.parseInt(line.getOptionValue("p")));

        if (line.hasOption("l"))
            classificationLearnerCustomizer.setL(Integer.parseInt(line.getOptionValue("l")));

        if (line.hasOption("v"))
            classificationLearnerCustomizer.printSvmPerfOutput(true);

        if (line.hasOption("s"))
            classificationLearnerCustomizer.setDeleteTrainingFiles(false);

        if (line.hasOption("t")) {
            classificationLearnerCustomizer.setTempPath(line.getOptionValue("t"));
            classificationCustomizer.setTempPath(line.getOptionValue("t"));
        }

    } catch (Exception exp) {
        System.err.println("Parsing failed.  Reason: " + exp.getMessage());
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(cmdLineSyntax, options);
        System.exit(-1);
    }

    assert (classificationLearnerCustomizer != null);

    if (remainingArgs.length != 4) {
        HelpFormatter formatter = new HelpFormatter();
        formatter.printHelp(cmdLineSyntax, options);
        System.exit(-1);
    }

    String indexFile = remainingArgs[2];

    File file = new File(indexFile);

    String indexName = file.getName();
    String indexPath = file.getParent();

    String outputPath = remainingArgs[3];

    SvmPerfLearner classificationLearner = new SvmPerfLearner();

    classificationLearner.setRuntimeCustomizer(classificationLearnerCustomizer);

    FileSystemStorageManager fssm = new FileSystemStorageManager(indexPath, false);
    fssm.open();

    IIndex training = TroveReadWriteHelper.readIndex(fssm, indexName, TroveContentDBType.Full,
            TroveClassificationDBType.Full);

    final TextualProgressBar progressBar = new TextualProgressBar("Learning the quantifiers");

    IOperationStatusListener status = new IOperationStatusListener() {

        @Override
        public void operationStatus(double percentage) {
            progressBar.signal((int) percentage);
        }
    };

    QuantificationLearner quantificationLearner = new QuantificationLearner(folds, classificationLearner,
            classificationLearnerCustomizer, classificationCustomizer, ClassificationMode.PER_CATEGORY,
            new LogisticFunction(), status);

    IQuantifier[] quantifiers = quantificationLearner.learn(training);

    File executableFile = new File(classificationLearnerCustomizer.getSvmPerfLearnPath());
    IDataManager classifierDataManager = new SvmPerfDataManager(new SvmPerfClassifierCustomizer(
            executableFile.getParentFile().getAbsolutePath() + Os.pathSeparator() + "svm_perf_classify"));
    String description = "_SVMPerf_C-" + classificationLearnerCustomizer.getC() + "_W-"
            + classificationLearnerCustomizer.getW() + "_L-" + classificationLearnerCustomizer.getL();
    if (classificationLearnerCustomizer.getL() == 4 || classificationLearnerCustomizer.getL() == 5)
        description += "_P-" + classificationLearnerCustomizer.getP();
    if (classificationLearnerCustomizer.getAdditionalParameters().length() > 0)
        description += "_" + classificationLearnerCustomizer.getAdditionalParameters();
    String quantifierPrefix = indexName + "_Quantifier-" + folds + description;

    FileSystemStorageManager fssmo = new FileSystemStorageManager(
            outputPath + File.separatorChar + quantifierPrefix, true);
    fssmo.open();
    QuantificationLearner.write(quantifiers, fssmo, classifierDataManager);
    fssmo.close();

    BufferedWriter bfs = new BufferedWriter(
            new FileWriter(outputPath + File.separatorChar + quantifierPrefix + "_rates.txt"));
    TShortDoubleHashMap simpleTPRs = quantificationLearner.getSimpleTPRs();
    TShortDoubleHashMap simpleFPRs = quantificationLearner.getSimpleFPRs();
    TShortDoubleHashMap scaledTPRs = quantificationLearner.getScaledTPRs();
    TShortDoubleHashMap scaledFPRs = quantificationLearner.getScaledFPRs();

    ContingencyTableSet contingencyTableSet = quantificationLearner.getContingencyTableSet();

    short[] cats = simpleTPRs.keys();
    for (int i = 0; i < cats.length; ++i) {
        short cat = cats[i];
        String catName = training.getCategoryDB().getCategoryName(cat);
        ContingencyTable contingencyTable = contingencyTableSet.getCategoryContingencyTable(cat);
        double simpleTPR = simpleTPRs.get(cat);
        double simpleFPR = simpleFPRs.get(cat);
        double scaledTPR = scaledTPRs.get(cat);
        double scaledFPR = scaledFPRs.get(cat);
        String line = quantifierPrefix + "\ttrain\tsimple\t" + catName + "\t" + cat + "\t"
                + contingencyTable.tp() + "\t" + contingencyTable.fp() + "\t" + contingencyTable.fn() + "\t"
                + contingencyTable.tn() + "\t" + simpleTPR + "\t" + simpleFPR + "\n";
        bfs.write(line);
        line = quantifierPrefix + "\ttrain\tscaled\t" + catName + "\t" + cat + "\t" + contingencyTable.tp()
                + "\t" + contingencyTable.fp() + "\t" + contingencyTable.fn() + "\t" + contingencyTable.tn()
                + "\t" + scaledTPR + "\t" + scaledFPR + "\n";
        bfs.write(line);
    }
    bfs.close();
}

From source file:es.csic.iiia.planes.generator.Cli.java

/**
 * Generator's cli entry point.//from   w  ww  . j a  v  a2s .co  m
 *
 * @param args the command line arguments
 */
public static void main(String[] args) {
    initializeLogging();

    options.addOption("d", "dump-settings", false,
            "dump the default settings to standard output. This can be used to prepare a settings file.");
    options.addOption("h", "help", false, "show this help message.");
    options.addOption(OptionBuilder.withArgName("setting=value").hasArgs(2).withValueSeparator()
            .withDescription("override \"setting\" with \"value\".")
            //.withLongOpt("override")
            .create('o'));
    options.addOption("q", "quiet", false, "disable all output except for results and errors.");
    options.addOption(OptionBuilder.withArgName("file").hasArg().withDescription("Load settings from <file>.")
            .withLongOpt("settings").create('s'));
    options.addOption(OptionBuilder.withLongOpt("dry-run")
            .withDescription("Output only the resolved settings, but do not run the simulation.").create('t'));

    Configuration config = parseOptions(args);
    Generator g = new Generator(config);
    g.run();
}