Java tutorial
/*********************************************************************************************************************** * Copyright (C) 2010-2013 by the Stratosphere project (http://stratosphere.eu) * * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the * specific language governing permissions and limitations under the License. **********************************************************************************************************************/ package eu.stratosphere.client; import java.io.File; import java.io.IOException; import java.net.InetSocketAddress; import java.text.SimpleDateFormat; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.Date; import java.util.List; import java.util.Map; import org.apache.commons.cli.CommandLine; import org.apache.commons.cli.CommandLineParser; import org.apache.commons.cli.HelpFormatter; import org.apache.commons.cli.MissingOptionException; import org.apache.commons.cli.Option; import org.apache.commons.cli.Options; import org.apache.commons.cli.ParseException; import org.apache.commons.cli.PosixParser; import org.apache.commons.cli.UnrecognizedOptionException; import org.apache.commons.io.FileUtils; import eu.stratosphere.api.common.JobExecutionResult; import eu.stratosphere.api.common.accumulators.AccumulatorHelper; import eu.stratosphere.client.program.Client; import eu.stratosphere.client.program.PackagedProgram; import eu.stratosphere.client.program.ProgramInvocationException; import eu.stratosphere.configuration.ConfigConstants; import eu.stratosphere.configuration.Configuration; import eu.stratosphere.configuration.GlobalConfiguration; import eu.stratosphere.nephele.event.job.RecentJobEvent; import eu.stratosphere.nephele.ipc.RPC; import eu.stratosphere.nephele.jobgraph.JobID; import eu.stratosphere.nephele.jobgraph.JobStatus; import eu.stratosphere.nephele.net.NetUtils; import eu.stratosphere.nephele.protocols.ExtendedManagementProtocol; import eu.stratosphere.util.StringUtils; /** * Implementation of a simple command line fronted for executing programs. */ public class CliFrontend { //actions private static final String ACTION_RUN = "run"; private static final String ACTION_INFO = "info"; private static final String ACTION_LIST = "list"; private static final String ACTION_CANCEL = "cancel"; // general options private static final Option HELP_OPTION = new Option("h", "help", false, "Show the help for the CLI Frontend."); private static final Option VERBOSE_OPTION = new Option("v", "verbose", false, "Print more detailed error messages."); // program (jar file) specific options private static final Option JAR_OPTION = new Option("j", "jarfile", true, "Stratosphere program JAR file."); private static final Option CLASS_OPTION = new Option("c", "class", true, "Class with the program entry point (\"main\" method or \"getPlan()\" method. Only needed if the JAR file does not specify the class in its manifest."); private static final Option PARALLELISM_OPTION = new Option("p", "parallelism", true, "The parallelism with which to run the program. Optional flag to override the default value specified in the configuration."); private static final Option ARGS_OPTION = new Option("a", "arguments", true, "Program arguments. Arguments can also be added without -a, simply as trailing parameters."); private static final Option ADDRESS_OPTION = new Option("m", "jobmanager", true, "Address of the JobManager (master) to which to connect. Use this flag to connect to a different JobManager than the one specified in the configuration."); // info specific options private static final Option DESCR_OPTION = new Option("d", "description", false, "Show description of expected program arguments"); private static final Option PLAN_OPTION = new Option("e", "executionplan", false, "Show optimized execution plan of the program (JSON)"); // list specific options private static final Option RUNNING_OPTION = new Option("r", "running", false, "Show running programs and their JobIDs"); private static final Option SCHEDULED_OPTION = new Option("s", "scheduled", false, "Show scheduled prorgrams and their JobIDs"); // canceling private static final Option ID_OPTION = new Option("i", "jobid", true, "JobID of program to cancel"); static { initOptions(); } // general options private static final Options GENRAL_OPTIONS = createGeneralOptions(); // action options all include the general options private static final Options RUN_OPTIONS = getRunOptions(createGeneralOptions()); private static final Options INFO_OPTIONS = getInfoOptions(createGeneralOptions()); private static final Options LIST_OPTIONS = getListOptions(createGeneralOptions()); private static final Options CANCEL_OPTIONS = getCancelOptions(createGeneralOptions()); // config dir parameters private static final String ENV_CONFIG_DIRECTORY = "STRATOSPHERE_CONF_DIR"; private static final String CONFIG_DIRECTORY_FALLBACK_1 = "../conf"; private static final String CONFIG_DIRECTORY_FALLBACK_2 = "conf"; public static final String JOBMANAGER_ADDRESS_FILE = ".yarn-jobmanager"; private CommandLineParser parser; private boolean verbose; private boolean printHelp; private boolean globalConfigurationLoaded; /** * Initializes the class */ public CliFrontend() { parser = new PosixParser(); } // -------------------------------------------------------------------------------------------- // Setup of options // -------------------------------------------------------------------------------------------- private static void initOptions() { HELP_OPTION.setRequired(false); VERBOSE_OPTION.setRequired(false); JAR_OPTION.setRequired(false); JAR_OPTION.setArgName("jarfile"); CLASS_OPTION.setRequired(false); CLASS_OPTION.setArgName("classname"); ADDRESS_OPTION.setRequired(false); ADDRESS_OPTION.setArgName("host:port"); PARALLELISM_OPTION.setRequired(false); PARALLELISM_OPTION.setArgName("parallelism"); ARGS_OPTION.setRequired(false); ARGS_OPTION.setArgName("programArgs"); ARGS_OPTION.setArgs(Option.UNLIMITED_VALUES); PLAN_OPTION.setRequired(false); DESCR_OPTION.setRequired(false); RUNNING_OPTION.setRequired(false); SCHEDULED_OPTION.setRequired(false); ID_OPTION.setRequired(false); ID_OPTION.setArgName("jobID"); } static Options createGeneralOptions() { Options options = new Options(); options.addOption(HELP_OPTION); options.addOption(VERBOSE_OPTION); return options; } // gets the program options with the old flags for jar file and arguments static Options getProgramSpecificOptions(Options options) { options.addOption(JAR_OPTION); options.addOption(CLASS_OPTION); options.addOption(PARALLELISM_OPTION); options.addOption(ARGS_OPTION); return options; } // gets the program options without the old flags for jar file and arguments static Options getProgramSpecificOptionsWithoutDeprecatedOptions(Options options) { options.addOption(CLASS_OPTION); options.addOption(PARALLELISM_OPTION); return options; } /** * Builds command line options for the run action. * * @return Command line options for the run action. */ static Options getRunOptions(Options options) { Options o = getProgramSpecificOptions(options); return getJobManagerAddressOption(o); } static Options getRunOptionsWithoutDeprecatedOptions(Options options) { Options o = getProgramSpecificOptionsWithoutDeprecatedOptions(options); return getJobManagerAddressOption(o); } static Options getJobManagerAddressOption(Options options) { options.addOption(ADDRESS_OPTION); return options; } /** * Builds command line options for the info action. * * @return Command line options for the info action. */ static Options getInfoOptions(Options options) { options = getProgramSpecificOptions(options); options = getJobManagerAddressOption(options); options.addOption(DESCR_OPTION); options.addOption(PLAN_OPTION); return options; } static Options getInfoOptionsWithoutDeprecatedOptions(Options options) { options = getProgramSpecificOptionsWithoutDeprecatedOptions(options); options = getJobManagerAddressOption(options); options.addOption(DESCR_OPTION); options.addOption(PLAN_OPTION); return options; } /** * Builds command line options for the list action. * * @return Command line options for the list action. */ static Options getListOptions(Options options) { options.addOption(RUNNING_OPTION); options.addOption(SCHEDULED_OPTION); options = getJobManagerAddressOption(options); return options; } /** * Builds command line options for the cancel action. * * @return Command line options for the cancel action. */ static Options getCancelOptions(Options options) { options.addOption(ID_OPTION); options = getJobManagerAddressOption(options); return options; } // -------------------------------------------------------------------------------------------- // Execute Actions // -------------------------------------------------------------------------------------------- /** * Executions the run action. * * @param args Command line arguments for the run action. */ protected int run(String[] args) { // Parse command line options CommandLine line; try { line = parser.parse(RUN_OPTIONS, args, false); evaluateGeneralOptions(line); } catch (MissingOptionException e) { System.out.println(e.getMessage()); printHelpForRun(); return 1; } catch (UnrecognizedOptionException e) { System.out.println(e.getMessage()); printHelpForRun(); return 2; } catch (Exception e) { return handleError(e); } // ------------ check for help first -------------- if (printHelp) { printHelpForRun(); return 0; } try { PackagedProgram program = buildProgram(line); if (program == null) { printHelpForRun(); return 1; } Client client = getClient(line); if (client == null) { printHelpForRun(); return 1; } int parallelism = -1; if (line.hasOption(PARALLELISM_OPTION.getOpt())) { String parString = line.getOptionValue(PARALLELISM_OPTION.getOpt()); try { parallelism = Integer.parseInt(parString); } catch (NumberFormatException e) { System.out.println("The value " + parString + " is invalid for the degree of parallelism."); printHelpForRun(); return 1; } if (parallelism <= 0) { System.out.println( "Invalid value for the degree-of-parallelism. Parallelism must be greater than zero."); printHelpForRun(); return 1; } } return executeProgram(program, client, parallelism); } catch (Throwable t) { return handleError(t); } } // -------------------------------------------------------------------------------------------- protected int executeProgram(PackagedProgram program, Client client, int parallelism) { JobExecutionResult execResult; try { client.setPrintStatusDuringExecution(true); execResult = client.run(program, parallelism, true); } catch (ProgramInvocationException e) { return handleError(e); } finally { program.deleteExtractedLibraries(); } // we come here after the job has finished if (execResult != null) { System.out.println("Job Runtime: " + execResult.getNetRuntime()); Map<String, Object> accumulatorsResult = execResult.getAllAccumulatorResults(); if (accumulatorsResult.size() > 0) { System.out.println("Accumulator Results: "); System.out.println(AccumulatorHelper.getResultsFormated(accumulatorsResult)); } } return 0; } // -------------------------------------------------------------------------------------------- /** * Executes the info action. * * @param args Command line arguments for the info action. */ protected int info(String[] args) { // Parse command line options CommandLine line; try { line = parser.parse(INFO_OPTIONS, args, false); evaluateGeneralOptions(line); } catch (MissingOptionException e) { System.out.println(e.getMessage()); printHelpForInfo(); return 1; } catch (UnrecognizedOptionException e) { System.out.println(e.getMessage()); printHelpForInfo(); return 2; } catch (Exception e) { return handleError(e); } if (printHelp) { printHelpForInfo(); return 0; } boolean description = line.hasOption(DESCR_OPTION.getOpt()); boolean plan = line.hasOption(PLAN_OPTION.getOpt()); if (!description && !plan) { System.out.println("ERROR: Specify the information to display."); printHelpForInfo(); return 1; } // -------- build the packaged program ------------- PackagedProgram program; try { program = buildProgram(line); } catch (Throwable t) { return handleError(t); } if (program == null) { printHelpForInfo(); return 1; } int parallelism = -1; if (line.hasOption(PARALLELISM_OPTION.getOpt())) { String parString = line.getOptionValue(PARALLELISM_OPTION.getOpt()); try { parallelism = Integer.parseInt(parString); } catch (NumberFormatException e) { System.out.println("The value " + parString + " is invalid for the degree of parallelism."); printHelpForRun(); return 1; } if (parallelism <= 0) { System.out.println( "Invalid value for the degree-of-parallelism. Parallelism must be greater than zero."); printHelpForRun(); return 1; } } try { // check for description request if (description) { String descr = program.getDescription(); if (descr != null) { System.out.println("-------------------- Program Description ---------------------"); System.out.println(descr); System.out.println("--------------------------------------------------------------"); } else { System.out.println("No description available for this program."); } } // check for json plan request if (plan) { Client client = getClient(line); String jsonPlan = client.getOptimizedPlanAsJson(program, parallelism); if (jsonPlan != null) { System.out.println("----------------------- Execution Plan -----------------------"); System.out.println(jsonPlan); System.out.println("--------------------------------------------------------------"); } else { System.out.println("JSON plan could not be compiled."); } } return 0; } catch (Throwable t) { return handleError(t); } finally { program.deleteExtractedLibraries(); } } /** * Executes the list action. * * @param args Command line arguments for the list action. */ protected int list(String[] args) { // Parse command line options CommandLine line; try { line = parser.parse(LIST_OPTIONS, args, false); } catch (MissingOptionException e) { System.out.println(e.getMessage()); printHelpForList(); return 1; } catch (UnrecognizedOptionException e) { System.out.println(e.getMessage()); printHelpForList(); return 2; } catch (Exception e) { return handleError(e); } if (printHelp) { printHelpForList(); return 0; } // get list options boolean running = line.hasOption(RUNNING_OPTION.getOpt()); boolean scheduled = line.hasOption(SCHEDULED_OPTION.getOpt()); if (!running && !scheduled) { System.out.println("Error: Specify the status of the jobs to list."); printHelpForList(); return 1; } ExtendedManagementProtocol jmConn = null; try { jmConn = getJobManagerConnection(line); if (jmConn == null) { printHelpForList(); return 1; } List<RecentJobEvent> recentJobs = jmConn.getRecentJobs(); ArrayList<RecentJobEvent> runningJobs = null; ArrayList<RecentJobEvent> scheduledJobs = null; if (running) { runningJobs = new ArrayList<RecentJobEvent>(); } if (scheduled) { scheduledJobs = new ArrayList<RecentJobEvent>(); } for (RecentJobEvent rje : recentJobs) { if (running && rje.getJobStatus().equals(JobStatus.RUNNING)) { runningJobs.add(rje); } if (scheduled && rje.getJobStatus().equals(JobStatus.SCHEDULED)) { scheduledJobs.add(rje); } } SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:ss"); Comparator<RecentJobEvent> njec = new Comparator<RecentJobEvent>() { @Override public int compare(RecentJobEvent o1, RecentJobEvent o2) { return (int) (o1.getTimestamp() - o2.getTimestamp()); } }; if (running) { if (runningJobs.size() == 0) { System.out.println("No running jobs."); } else { Collections.sort(runningJobs, njec); System.out.println("------------------------ Running Jobs ------------------------"); for (RecentJobEvent je : runningJobs) { System.out.println(df.format(new Date(je.getTimestamp())) + " : " + je.getJobID().toString() + " : " + je.getJobName()); } System.out.println("--------------------------------------------------------------"); } } if (scheduled) { if (scheduledJobs.size() == 0) { System.out.println("No scheduled jobs."); } else { Collections.sort(scheduledJobs, njec); System.out.println("----------------------- Scheduled Jobs -----------------------"); for (RecentJobEvent je : scheduledJobs) { System.out.println(df.format(new Date(je.getTimestamp())) + " : " + je.getJobID().toString() + " : " + je.getJobName()); } System.out.println("--------------------------------------------------------------"); } } return 0; } catch (Throwable t) { return handleError(t); } finally { if (jmConn != null) { try { RPC.stopProxy(jmConn); } catch (Throwable t) { System.out.println("Could not cleanly shut down connection from compiler to job manager"); } } jmConn = null; } } /** * Executes the cancel action. * * @param args Command line arguments for the cancel action. */ protected int cancel(String[] args) { // Parse command line options CommandLine line; try { line = parser.parse(CANCEL_OPTIONS, args, false); } catch (MissingOptionException e) { System.out.println(e.getMessage()); printHelpForCancel(); return 1; } catch (UnrecognizedOptionException e) { System.out.println(e.getMessage()); printHelpForCancel(); return 2; } catch (Exception e) { return handleError(e); } if (printHelp) { printHelpForCancel(); return 0; } JobID jobId; if (line.hasOption(ID_OPTION.getOpt())) { String jobIdString = line.getOptionValue(ID_OPTION.getOpt()); try { jobId = new JobID(StringUtils.hexStringToByte(jobIdString)); } catch (Exception e) { System.out.println("Error: The value for the Job ID is not a valid ID."); printHelpForCancel(); return 1; } } else { System.out.println("Error: Specify a Job ID to cancel a job."); printHelpForCancel(); return 1; } ExtendedManagementProtocol jmConn = null; try { jmConn = getJobManagerConnection(line); if (jmConn == null) { printHelpForCancel(); return 1; } jmConn.cancelJob(jobId); return 0; } catch (Throwable t) { return handleError(t); } finally { if (jmConn != null) { try { RPC.stopProxy(jmConn); } catch (Throwable t) { System.out.println("Warning: Could not cleanly shut down connection to the JobManager."); } } jmConn = null; } } /** * @param line * * @return Either a PackagedProgram (upon success), or null; */ protected PackagedProgram buildProgram(CommandLine line) { String[] programArgs = line.hasOption(ARGS_OPTION.getOpt()) ? line.getOptionValues(ARGS_OPTION.getOpt()) : line.getArgs(); // take the jar file from the option, or as the first trailing parameter (if available) String jarFilePath = null; if (line.hasOption(JAR_OPTION.getOpt())) { jarFilePath = line.getOptionValue(JAR_OPTION.getOpt()); } else if (programArgs.length > 0) { jarFilePath = programArgs[0]; programArgs = Arrays.copyOfRange(programArgs, 1, programArgs.length); } else { System.out.println("Error: Jar file is not set."); return null; } File jarFile = new File(jarFilePath); // Check if JAR file exists if (!jarFile.exists()) { System.out.println("Error: Jar file does not exist."); return null; } else if (!jarFile.isFile()) { System.out.println("Error: Jar file is not a file."); return null; } // Get assembler class String entryPointClass = line.hasOption(CLASS_OPTION.getOpt()) ? line.getOptionValue(CLASS_OPTION.getOpt()) : null; try { return entryPointClass == null ? new PackagedProgram(jarFile, programArgs) : new PackagedProgram(jarFile, entryPointClass, programArgs); } catch (ProgramInvocationException e) { handleError(e); return null; } } protected InetSocketAddress getJobManagerAddress(CommandLine line) throws IOException { Configuration configuration = getGlobalConfiguration(); // first, check if the address comes from the command line option if (line.hasOption(ADDRESS_OPTION.getOpt())) { try { String address = line.getOptionValue(ADDRESS_OPTION.getOpt()); return RemoteExecutor.getInetFromHostport(address); } catch (Exception e) { System.out.println("Error: The JobManager address has an invalid format. " + e.getMessage()); return null; } } else { // second, search for a .yarn-jobmanager file String loc = getConfigurationDirectory(); File jmAddressFile = new File(loc + '/' + JOBMANAGER_ADDRESS_FILE); if (jmAddressFile.exists()) { try { String address = FileUtils.readFileToString(jmAddressFile).trim(); System.out.println("Found a " + JOBMANAGER_ADDRESS_FILE + " file, using \"" + address + "\" to connect to the JobManager"); return RemoteExecutor.getInetFromHostport(address); } catch (Exception e) { System.out.println("Found a " + JOBMANAGER_ADDRESS_FILE + " file, but could not read the JobManager address from the file. " + e.getMessage()); return null; } } else { // regular config file gives the address String jobManagerAddress = configuration.getString(ConfigConstants.JOB_MANAGER_IPC_ADDRESS_KEY, null); // verify that there is a jobmanager address and port in the configuration if (jobManagerAddress == null) { System.out.println("Error: Found no configuration in the config directory '" + getConfigurationDirectory() + "' that specifies the JobManager address."); return null; } int jobManagerPort; try { jobManagerPort = configuration.getInteger(ConfigConstants.JOB_MANAGER_IPC_PORT_KEY, -1); } catch (NumberFormatException e) { System.out.println("Invalid value for the JobManager IPC port (" + ConfigConstants.JOB_MANAGER_IPC_PORT_KEY + ") in the configuration."); return null; } if (jobManagerPort == -1) { System.out.println("Error: Found no configuration in the config directory '" + getConfigurationDirectory() + "' that specifies the JobManager port."); return null; } return new InetSocketAddress(jobManagerAddress, jobManagerPort); } } } protected ExtendedManagementProtocol getJobManagerConnection(CommandLine line) throws IOException { InetSocketAddress jobManagerAddress = getJobManagerAddress(line); if (jobManagerAddress == null) { return null; } String address = jobManagerAddress.getAddress().getHostAddress(); int port = jobManagerAddress.getPort(); return RPC.getProxy(ExtendedManagementProtocol.class, new InetSocketAddress(address, port), NetUtils.getSocketFactory()); } protected String getConfigurationDirectory() { String location = null; if (System.getenv(ENV_CONFIG_DIRECTORY) != null) { location = System.getenv(ENV_CONFIG_DIRECTORY); } else if (new File(CONFIG_DIRECTORY_FALLBACK_1).exists()) { location = CONFIG_DIRECTORY_FALLBACK_1; } else if (new File(CONFIG_DIRECTORY_FALLBACK_2).exists()) { location = CONFIG_DIRECTORY_FALLBACK_2; } else { throw new RuntimeException("The configuration directory was not found. Please configure the '" + ENV_CONFIG_DIRECTORY + "' environment variable properly."); } return location; } /** * Reads configuration settings. The default path can be overridden * by setting the ENV variable "STRATOSPHERE_CONF_DIR". * * @return Stratosphere's global configuration */ protected Configuration getGlobalConfiguration() { if (!globalConfigurationLoaded) { String location = getConfigurationDirectory(); GlobalConfiguration.loadConfiguration(location); globalConfigurationLoaded = true; } return GlobalConfiguration.getConfiguration(); } protected Client getClient(CommandLine line) throws IOException { return new Client(getJobManagerAddress(line), getGlobalConfiguration()); } /** * Prints the help for the client. * * @param options A map with options for actions. */ private void printHelp() { System.out.println("./stratosphere <ACTION> [GENERAL_OPTIONS] [ARGUMENTS]"); HelpFormatter formatter = new HelpFormatter(); formatter.setWidth(80); formatter.setLeftPadding(5); formatter.setSyntaxPrefix(" general options:"); formatter.printHelp(" ", GENRAL_OPTIONS); printHelpForRun(); printHelpForInfo(); printHelpForList(); printHelpForCancel(); } private void printHelpForRun() { HelpFormatter formatter = new HelpFormatter(); formatter.setLeftPadding(5); formatter.setWidth(80); System.out.println("\nAction \"run\" compiles and runs a program."); System.out.println("\n Syntax: run [OPTIONS] <jar-file> <arguments>"); formatter.setSyntaxPrefix(" \"run\" action arguments:"); formatter.printHelp(" ", getRunOptionsWithoutDeprecatedOptions(new Options())); } private void printHelpForInfo() { HelpFormatter formatter = new HelpFormatter(); formatter.setLeftPadding(5); formatter.setWidth(80); System.out.println("\nAction \"info\" displays information about a program."); formatter.setSyntaxPrefix(" \"info\" action arguments:"); formatter.printHelp(" ", getInfoOptionsWithoutDeprecatedOptions(new Options())); } private void printHelpForList() { HelpFormatter formatter = new HelpFormatter(); formatter.setLeftPadding(5); formatter.setWidth(80); System.out.println("\nAction \"list\" lists running and finished programs."); formatter.setSyntaxPrefix(" \"list\" action arguments:"); formatter.printHelp(" ", getListOptions(new Options())); } private void printHelpForCancel() { HelpFormatter formatter = new HelpFormatter(); formatter.setLeftPadding(5); formatter.setWidth(80); System.out.println("\nAction \"cancel\" cancels a running program."); formatter.setSyntaxPrefix(" \"cancel\" action arguments:"); formatter.printHelp(" ", getCancelOptions(new Options())); } /** * Displays exceptions. * * @param e the exception to display. */ private int handleError(Throwable t) { System.out.println("Error: " + t.getMessage()); if (this.verbose) { t.printStackTrace(); } else { System.out.println("For a more detailed error message use the vebose output option '-v'."); } return 1; } private void evaluateGeneralOptions(CommandLine line) { // check help flag this.printHelp = line.hasOption(HELP_OPTION.getOpt()); // check verbosity flag this.verbose = line.hasOption(VERBOSE_OPTION.getOpt()); } /** * Parses the command line arguments and starts the requested action. * * @param args command line arguments of the client. * @return The return code of the program */ public int parseParameters(String[] args) { // check for action if (args.length < 1) { System.out.println("Please specify an action."); printHelp(); return 1; } // get action String action = args[0]; // remove action from parameters String[] params = Arrays.copyOfRange(args, 1, args.length); // do action if (action.equals(ACTION_RUN)) { return run(params); } else if (action.equals(ACTION_LIST)) { return list(params); } else if (action.equals(ACTION_INFO)) { return info(params); } else if (action.equals(ACTION_CANCEL)) { return cancel(params); } else if (action.equals("-h") || action.equals("--help")) { printHelp(); return 0; } else { System.out.println("Invalid action!"); printHelp(); return 1; } } /** * Submits the job based on the arguments */ public static void main(String[] args) throws ParseException { CliFrontend cli = new CliFrontend(); int retCode = cli.parseParameters(args); System.exit(retCode); } }