Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You 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 org.apache.easyant.core; import org.apache.commons.cli.*; import org.apache.easyant.core.ant.ProjectUtils; import org.apache.easyant.core.configuration.EasyAntConfiguration; import org.apache.easyant.core.configuration.EasyantConfigurationFactory; import org.apache.easyant.man.*; import org.apache.tools.ant.*; import org.apache.tools.ant.launch.AntMain; import org.apache.tools.ant.util.FileUtils; import java.io.*; import java.util.*; /** * Command line entry point into EasyAnt. This class is entered via the canonical `public static void main` entry point * and reads the command line arguments. It then assembles and executes an Ant project. * <p> * If you integrating EasyAnt into some other tool, this is not the class to use as an entry point. Instead you should * have a look at {@link EasyAntEngine}. * </p> */ public class EasyAntMain implements AntMain { /** * A Set of args are are handled by the launcher and should not be seen by Main. */ private static final Set<String> LAUNCH_COMMANDS = new HashSet<String>(); private boolean isLogFileUsed; static { LAUNCH_COMMANDS.add("-lib"); LAUNCH_COMMANDS.add("-cp"); LAUNCH_COMMANDS.add("-noclasspath"); LAUNCH_COMMANDS.add("--noclasspath"); LAUNCH_COMMANDS.add("-nouserlib"); LAUNCH_COMMANDS.add("-main"); } private EasyAntConfiguration easyAntConfiguration; private boolean projectHelp; private Options options = new Options(); /** * Whether or not this instance has successfully been constructed and is ready to run. */ private boolean readyToRun; private List<String> propertyFiles = new ArrayList<String>(1); /** * Prints the message of the Throwable if it (the message) is not <code>null</code>. * * @param t Throwable to print the message of. Must not be <code>null</code>. */ private static void printMessage(Throwable t) { String message = t.getMessage(); if (message != null) { System.err.println(message); } } /** * Creates a new instance of this class using the arguments specified, gives it any extra user properties which have * been specified, and then runs the build using the classloader provided. * * @param args Command line arguments. Must not be <code>null</code>. * @param additionalUserProperties Any extra properties to use in this build. May be <code>null</code>, which is the equivalent to * passing in an empty set of properties. * @param coreLoader Classloader used for core classes. May be <code>null</code> in which case the system classloader is * used. */ public static void start(String[] args, Properties additionalUserProperties, ClassLoader coreLoader) { EasyAntMain m = new EasyAntMain(); m.startAnt(args, additionalUserProperties, coreLoader); } /** * Start Ant * * @param args command line args * @param additionalUserProperties properties to set beyond those that may be specified on the args list * @param coreLoader - not used * @since Ant 1.6 */ public void startAnt(String[] args, Properties additionalUserProperties, ClassLoader coreLoader) { easyAntConfiguration.setCoreLoader(coreLoader); configureOptions(); CommandLineParser parser = new GnuParser(); CommandLine line; try { line = parser.parse(options, args); processArgs(line); } catch (ParseException exc) { if (easyAntConfiguration.getMsgOutputLevel() >= Project.MSG_VERBOSE) { exc.printStackTrace(); } handleLogfile(); printMessage(exc); exit(1); return; } if (additionalUserProperties != null) { Enumeration<?> properties = additionalUserProperties.propertyNames(); while (properties.hasMoreElements()) { String key = (String) properties.nextElement(); String property = additionalUserProperties.getProperty(key); easyAntConfiguration.getDefinedProps().put(key, property); } } // expect the worst int exitCode = 1; try { try { runBuild(line); exitCode = 0; } catch (ExitStatusException ese) { exitCode = ese.getStatus(); if (exitCode != 0) { throw ese; } } } catch (BuildException be) { // do nothing they have been already logged by our logger } catch (Throwable exc) { exc.printStackTrace(); printMessage(exc); } finally { handleLogfile(); } exit(exitCode); } /** * This operation is expected to call {@link System#exit(int)}, which is what the base version does. However, it is * possible to do something else. * * @param exitCode code to exit with */ protected void exit(int exitCode) { System.exit(exitCode); } /** * Close logfiles, if we have been writing to them. * * @since Ant 1.6 */ private void handleLogfile() { if (isLogFileUsed && easyAntConfiguration != null) { FileUtils.close(easyAntConfiguration.getOut()); FileUtils.close(easyAntConfiguration.getErr()); } } /** * Command line entry point. This method kicks off the building of a project object and executes a build using * either a given target or the default target. * * @param args Command line arguments. Must not be <code>null</code>. */ public static void main(String[] args) { start(args, null, null); } /** * Constructor used when creating Main for later arg processing and startup */ public EasyAntMain() { easyAntConfiguration = EasyantConfigurationFactory.getInstance().createDefaultConfiguration(); } /** * Process command line arguments. When ant is started from Launcher, launcher-only arguments do not get passed * through to this routine. * * @since Ant 1.6 */ private void processArgs(CommandLine line) { String searchForThis; PrintStream logTo = null; if (line.hasOption("help")) { printUsage(); return; } if (easyAntConfiguration.getMsgOutputLevel() >= Project.MSG_VERBOSE || line.hasOption("version")) { printVersion(); if (line.hasOption("version")) { return; } } if (line.hasOption("showMemoryDetails")) { easyAntConfiguration.setShowMemoryDetails(true); } if (line.hasOption("diagnostics")) { Diagnostics.doReport(System.out, easyAntConfiguration.getMsgOutputLevel()); return; } if (line.hasOption("quiet")) { easyAntConfiguration.setMsgOutputLevel(Project.MSG_WARN); } if (line.hasOption("verbose")) { easyAntConfiguration.setMsgOutputLevel(Project.MSG_VERBOSE); } if (line.hasOption("debug")) { easyAntConfiguration.setMsgOutputLevel(Project.MSG_DEBUG); } if (line.hasOption("noinput")) { easyAntConfiguration.setAllowInput(false); } if (line.hasOption("logfile")) { try { File logFile = new File(line.getOptionValue("logfile")); logTo = new PrintStream(new FileOutputStream(logFile)); isLogFileUsed = true; } catch (IOException ioe) { String msg = "Cannot write on the specified log file. " + "Make sure the path exists and you have write " + "permissions."; throw new BuildException(msg); } catch (ArrayIndexOutOfBoundsException aioobe) { String msg = "You must specify a log file when " + "using the -log argument"; throw new BuildException(msg); } } if (line.hasOption("buildmodule")) { File buildModule = new File(line.getOptionValue("buildmodule").replace('/', File.separatorChar)); easyAntConfiguration.setBuildModule(buildModule); } if (line.hasOption("buildfile")) { File buildFile = new File(line.getOptionValue("buildfile").replace('/', File.separatorChar)); easyAntConfiguration.setBuildFile(buildFile); } if (line.hasOption("buildconf")) { easyAntConfiguration.getActiveBuildConfigurations().add(line.getOptionValue("buildconf")); } File easyantConfFile = null; if (line.hasOption("configfile")) { easyantConfFile = new File(line.getOptionValue("configfile").replace('/', File.separatorChar)); } else { // if no command line switch is specified check the default location File easyantHome = new File( System.getProperty(EasyAntMagicNames.EASYANT_HOME).replace('/', File.separatorChar)); File defaultGlobalEasyantConfFile = new File(easyantHome, EasyAntConstants.DEFAULT_GLOBAL_EASYANT_CONF_FILE); if (defaultGlobalEasyantConfFile.exists()) { easyantConfFile = defaultGlobalEasyantConfFile; } } if (easyantConfFile != null) { try { easyAntConfiguration = EasyantConfigurationFactory.getInstance() .createConfigurationFromFile(easyAntConfiguration, easyantConfFile.toURI().toURL()); } catch (Exception e) { throw new BuildException(e); } } if (line.hasOption("listener")) { easyAntConfiguration.getListeners().add(line.getOptionValue("listener")); } if (line.hasOption("D")) { easyAntConfiguration.getDefinedProps().putAll(line.getOptionProperties("D")); } if (line.hasOption("logger")) { if (easyAntConfiguration.getLoggerClassname() != null) { throw new BuildException("Only one logger class may be specified."); } easyAntConfiguration.setLoggerClassname(line.getOptionValue("logger")); } if (line.hasOption("inputhandler")) { if (easyAntConfiguration.getInputHandlerClassname() != null) { throw new BuildException("Only one input handler class may " + "be specified."); } easyAntConfiguration.setInputHandlerClassname(line.getOptionValue("inputhandler")); } if (line.hasOption("emacs")) { easyAntConfiguration.setEmacsMode(true); } if (line.hasOption("projecthelp")) { // set the flag to display the targets and quit projectHelp = true; } if (line.hasOption("find")) { // eat up next arg if present, default to module.ivy if (line.getOptionValues("find").length > 0) { searchForThis = line.getOptionValue("find"); } else { searchForThis = EasyAntConstants.DEFAULT_BUILD_MODULE; } easyAntConfiguration.setBuildModule(new File(searchForThis)); easyAntConfiguration.setBuildModuleLookupEnabled(true); } if (line.hasOption("propertyfile")) { propertyFiles.add(line.getOptionValue("propertyfile")); } if (line.hasOption("keep-going")) { easyAntConfiguration.setKeepGoingMode(true); } if (line.hasOption("offline")) { easyAntConfiguration.setOffline(true); } if (line.hasOption("nice")) { easyAntConfiguration.setThreadPriority(Integer.decode(line.getOptionValue("nice"))); if (easyAntConfiguration.getThreadPriority() < Thread.MIN_PRIORITY || easyAntConfiguration.getThreadPriority() > Thread.MAX_PRIORITY) { throw new BuildException("Niceness value is out of the range 1-10"); } } if (line.hasOption("autoproxy")) { easyAntConfiguration.setProxy(true); } if (!line.getArgList().isEmpty()) { for (Object o : line.getArgList()) { String target = (String) o; easyAntConfiguration.getTargets().add(target); } } // Load the property files specified by -propertyfile loadPropertyFiles(); if (logTo != null) { easyAntConfiguration.setOut(logTo); easyAntConfiguration.setErr(logTo); System.setOut(easyAntConfiguration.getOut()); System.setErr(easyAntConfiguration.getErr()); } readyToRun = true; } // -------------------------------------------------------- // other methods // -------------------------------------------------------- /** * Load the property files specified by -propertyfile */ private void loadPropertyFiles() { for (String filename : propertyFiles) { Properties props = new Properties(); FileInputStream fis = null; try { fis = new FileInputStream(filename); props.load(fis); } catch (IOException e) { System.out.println("Could not load property file " + filename + ": " + e.getMessage()); } finally { FileUtils.close(fis); } // ensure that -D properties take precedence Enumeration<?> properties = props.propertyNames(); while (properties.hasMoreElements()) { String name = (String) properties.nextElement(); if (easyAntConfiguration.getDefinedProps().getProperty(name) == null) { easyAntConfiguration.getDefinedProps().put(name, props.getProperty(name)); } } } } /** * Executes the build. If the constructor for this instance failed (e.g. returned after issuing a warning), this * method returns immediately. * * @throws BuildException if the build fails */ private void runBuild(CommandLine line) throws BuildException { if (!readyToRun) { return; } if (projectHelp) { displayProjectHelp(); } else { EasyAntEngine eaEngine = new EasyAntEngine(easyAntConfiguration); Project project = new Project(); eaEngine.configureEasyAnt(project); eaEngine.loadProject(project); // handle other easyant option (-listTargets,-describe,etc..) for (int i = 0; i < line.getOptions().length; i++) { if (line.getOptions()[i] instanceof EasyantOption) { EasyantOption eaoption = (EasyantOption) line.getOptions()[i]; eaoption.setProject(project); eaoption.execute(); if (eaoption.isStopBuild()) { return; } } } eaEngine.doBuild(project); } } /** * Prints the description of a project (if there is one) to <code>System.out</code>. * * @param project The project to display a description of. Must not be <code>null</code>. */ protected void printDescription(Project project) { if (project.getDescription() != null) { project.log(project.getDescription()); } } /** * Searches for the correct place to insert a name into a list so as to keep the list sorted alphabetically. * * @param names The current list of names. Must not be <code>null</code>. * @param name The name to find a place for. Must not be <code>null</code>. * @return the correct place in the list for the given name */ private static int findTargetPosition(List<String> names, String name) { int res = names.size(); for (int i = 0; i < names.size() && res == names.size(); i++) { if (name.compareTo(names.get(i)) < 0) { res = i; } } return res; } /** * Writes a formatted list of target names to <code>System.out</code> with an optional description. * * @param project the project instance. * @param names The names to be printed. Must not be <code>null</code>. * @param descriptions The associated target descriptions. May be <code>null</code>, in which case no descriptions are * displayed. If non- <code>null</code>, this should have as many elements as <code>names</code>. * @param heading The heading to display. Should not be <code>null</code>. * @param maxlen The maximum length of the names of the targets. If descriptions are given, they are padded to this * position so they line up (so long as the names really <i>are</i> shorter than this). */ private static void printTargets(Project project, List<String> names, List<String> descriptions, String heading, int maxlen) { if (!names.isEmpty()) { // now, start printing the targets and their descriptions String lSep = System.getProperty("line.separator"); String spaces = String.format("%" + maxlen + "s", ' '); StringBuilder msg = new StringBuilder(); msg.append(lSep).append(heading).append(lSep).append(lSep); for (int i = 0; i < names.size(); i++) { msg.append(" "); msg.append(names.get(i)); if (descriptions != null) { msg.append(spaces.substring(0, maxlen - (names.get(i)).length() + 2)); msg.append(descriptions.get(i)); } msg.append(lSep); } project.log(msg.toString(), Project.MSG_WARN); } } /** * Prints a list of all targets in the specified project to <code>System.out</code>, optionally including * subtargets. * * @param project The project to display a description of. Must not be <code>null</code>. * @param printSubTargets Whether or not subtarget names should also be printed. */ protected static void printTargets(Project project, boolean printSubTargets) { // find the target with the longest name int maxLength = 0; Map<String, Target> ptargets = ProjectUtils.removeDuplicateTargets(project.getTargets()); String targetName; String targetDescription; // split the targets in top-level and sub-targets depending // on the presence of a description List<String> topNames = new ArrayList<String>(); List<String> topDescriptions = new ArrayList<String>(); List<String> subNames = new ArrayList<String>(); List<String> highLevelTargets = new ArrayList<String>(); List<String> highLevelTargetsDescriptions = new ArrayList<String>(); for (Target currentTarget : ptargets.values()) { targetName = currentTarget.getName(); if (targetName.equals("")) { continue; } targetDescription = currentTarget.getDescription(); // maintain a sorted list of targets if (currentTarget instanceof ExtensionPoint && !currentTarget.getName().contains(":")) { int pos = findTargetPosition(highLevelTargets, targetName); highLevelTargets.add(pos, targetName); highLevelTargetsDescriptions.add(pos, targetDescription); } else if (targetDescription != null) { int pos = findTargetPosition(topNames, targetName); topNames.add(pos, targetName); topDescriptions.add(pos, targetDescription); } else { int pos = findTargetPosition(subNames, targetName); subNames.add(pos, targetName); } if (targetName.length() > maxLength) { maxLength = targetName.length(); } } printTargets(project, highLevelTargets, highLevelTargetsDescriptions, "High level targets:", maxLength); printTargets(project, topNames, topDescriptions, "Main targets:", maxLength); // if there were no main targets, we list all subtargets // as it means nothing has a description if (topNames.isEmpty()) { printSubTargets = true; } if (printSubTargets) { printTargets(project, subNames, null, "Other targets:", maxLength); } else { project.log( "Run easyant with '-v' or '--verbose' option to have the whole list of available targets / extension points"); } String defaultTarget = project.getDefaultTarget(); if (defaultTarget != null && !"".equals(defaultTarget)) { // shouldn't need to check but... project.log("Default target: " + defaultTarget); } } private void displayProjectHelp() { final Project project = new Project(); Throwable error = null; try { EasyAntEngine.configureAndLoadProject(project, easyAntConfiguration); printDescription(project); printTargets(project, easyAntConfiguration.getMsgOutputLevel() > Project.MSG_INFO); } catch (RuntimeException exc) { error = exc; throw exc; } finally { if (error != null) { project.log(error.toString(), Project.MSG_ERR); } } } /** * Configure command line options */ @SuppressWarnings("static-access") public void configureOptions() { options.addOption("h", "help", false, "print this message"); options.addOption("p", "projecthelp", false, "print project help information"); options.addOption("version", false, "print the version information and exit"); options.addOption("diagnostics", false, "print information that might be helpful to diagnose or report problems"); options.addOption("showMemoryDetails", false, "print memory details (used/free/total)"); options.addOption("q", "quiet", false, "be extra quiet"); options.addOption("v", "verbose", false, "be extra verbose"); options.addOption("d", "debug", false, "print debugging information"); options.addOption("e", "emacs", false, "produce logging information without adornments"); Option lib = OptionBuilder.withArgName("path").hasArg() .withDescription("specifies a path to search for jars and classes").create("lib"); options.addOption(lib); Option logfile = OptionBuilder.withArgName("file").hasArg().withDescription("use given file for log") .create("logfile"); options.addOption(logfile); Option logger = OptionBuilder.withArgName("classname").hasArg() .withDescription("the class which it to perform " + "logging").create("logger"); options.addOption(logger); Option listener = OptionBuilder.withArgName("classname").hasArg() .withDescription("add an instance of class as " + "a project listener").create("listener"); options.addOption(listener); Option buildfile = OptionBuilder.withArgName("file").hasArg().withDescription("use given buildfile") .create("buildfile"); options.addOption(buildfile); Option find = OptionBuilder.withArgName("file").hasOptionalArg() .withDescription("search for buildfile towards the " + "root of the filesystem and use it") .withLongOpt("find").create("s"); options.addOption(find); options.addOption("noinput", false, "do not allow interactive input"); Option buildmodule = OptionBuilder.withArgName("file").hasArg().withDescription("use given buildmodule") .withLongOpt("buildmodule").create("f"); options.addOption(buildmodule); Option buildconf = OptionBuilder.withArgName("confs").hasArg() .withDescription("specify build configurations (profiles)").withLongOpt("buildconf").create("C"); options.addOption(buildconf); Option configFile = OptionBuilder.withArgName("file").hasArg() .withDescription("use given easyant configuration").create("configfile"); options.addOption(configFile); Option property = OptionBuilder.withArgName("property=value").hasArgs(2).withValueSeparator() .withDescription("use value for given property").create("D"); options.addOption(property); options.addOption("k", "keep-going", false, "execute all targets that do not depend on failed target(s)"); Option propertiesfile = OptionBuilder.withArgName("file").hasArg() .withDescription("load all properties from file with -D properties taking precedence") .create("propertyfile"); options.addOption(propertiesfile); Option inputhandler = OptionBuilder.withArgName("classname").hasArg() .withDescription("the class which will handle input requests").create("inputhandler"); options.addOption(inputhandler); Option nice = OptionBuilder.withArgName("number").hasArg() .withDescription( "A niceness value for the main thread: 1 (lowest) to 10 (highest); 5 is the default") .create("nice"); options.addOption(nice); options.addOption("nouserlib", false, "Run ant without using the jar files from ${user.home}/.ant/lib"); options.addOption("noclasspath", false, "Run ant without using CLASSPATH"); options.addOption("autoproxy", false, "Java1.5+: use the OS proxy settings"); Option main = OptionBuilder.withArgName("classname").hasArg() .withDescription("override EasyAnt's normal entry point").create("main"); options.addOption(main); options.addOption("o", "offline", false, "turns EasyAnt in offline mode"); options.addOption(new Describe()); options.addOption(new ListExtensionPoints()); options.addOption(new ListTargets()); options.addOption(new ListProps()); options.addOption(new ListParameters()); options.addOption(new ListPlugins()); } /** * Prints the usage information for this class to <code>System.out</code>. */ private void printUsage() { HelpFormatter help = new HelpFormatter(); help.printHelp("easyant [options] [target [target2 [target3] ...]]", options); } /** * Prints the EasyAnt version information to <code>System.out</code>. * * @throws BuildException if the version information is unavailable */ private static void printVersion() throws BuildException { System.out.println(EasyAntEngine.getEasyAntVersion()); System.out.println(getAntVersion()); } /** * Cache of the Ant version information when it has been loaded. */ private static String antVersion = null; /** * Returns the Ant version information, if available. Once the information has been loaded once, it's cached and * returned from the cache on future calls. * * @return the Ant version information as a String (always non- <code>null</code>) * @throws BuildException if the version information is unavailable */ public static synchronized String getAntVersion() throws BuildException { if (antVersion == null) { InputStream in = null; try { Properties props = new Properties(); in = Main.class.getResourceAsStream("/org/apache/tools/ant/version.txt"); if (in == null) { throw new BuildException("Could not load the version information."); } props.load(in); antVersion = "Apache Ant version " + props.getProperty("VERSION") + " compiled on " + props.getProperty("DATE"); } catch (IOException ioe) { throw new BuildException("Could not load the version information", ioe); } finally { if (in != null) { try { in.close(); } catch (IOException e) { // do nothing } } } } return antVersion; } }