| /* |
| * 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.easyant.core.ant.ProjectUtils; |
| import org.apache.easyant.core.ant.listerners.DefaultEasyAntLogger; |
| import org.apache.easyant.core.configuration.EasyAntConfiguration; |
| import org.apache.easyant.core.configuration.EasyantConfigurationFactory; |
| import org.apache.easyant.core.descriptor.PluginDescriptor; |
| import org.apache.easyant.core.ivy.InheritableScope; |
| import org.apache.easyant.core.ivy.IvyInstanceHelper; |
| import org.apache.easyant.core.services.DefaultPluginService; |
| import org.apache.easyant.core.services.PluginService; |
| import org.apache.easyant.tasks.ConfigureBuildScopedRepository; |
| import org.apache.easyant.tasks.Import; |
| import org.apache.easyant.tasks.LoadModule; |
| import org.apache.ivy.Ivy; |
| import org.apache.ivy.ant.IvyAntSettings; |
| import org.apache.ivy.ant.IvyConfigure; |
| import org.apache.ivy.core.cache.EasyAntRepositoryCacheManager; |
| import org.apache.ivy.core.cache.EasyantResolutionCacheManager; |
| import org.apache.tools.ant.*; |
| import org.apache.tools.ant.input.DefaultInputHandler; |
| import org.apache.tools.ant.input.InputHandler; |
| import org.apache.tools.ant.util.ClasspathUtils; |
| import org.apache.tools.ant.util.FileUtils; |
| import org.apache.tools.ant.util.ProxySetup; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.PrintStream; |
| import java.lang.reflect.Method; |
| import java.net.JarURLConnection; |
| import java.net.MalformedURLException; |
| import java.net.URL; |
| import java.net.URLConnection; |
| import java.util.Enumeration; |
| import java.util.Properties; |
| import java.util.Vector; |
| |
| /** |
| * This class provides everything you need to run easyant. This class should be used to bootstrap easyant from IDE for |
| * example |
| */ |
| public class EasyAntEngine { |
| |
| private final EasyAntConfiguration configuration; |
| |
| private PluginService pluginService = null; |
| |
| /** |
| * Default constructor will initialize the default configuration |
| */ |
| public EasyAntEngine() { |
| this(EasyantConfigurationFactory.getInstance().createDefaultConfiguration()); |
| } |
| |
| /** |
| * Constructor if you want to use a custom configuration |
| * |
| * @param configuration |
| */ |
| public EasyAntEngine(final EasyAntConfiguration configuration) { |
| this.configuration = configuration; |
| } |
| |
| /** |
| * Configure easyant ivy instance |
| * |
| * @param project project instance |
| * @return a configured {@link IvyAntSettings} instance |
| */ |
| public IvyAntSettings configureEasyAntIvyInstance(Project project) { |
| IvyConfigure easyantIvyConfigure = new IvyConfigure(); |
| easyantIvyConfigure.setSettingsId(EasyAntMagicNames.EASYANT_IVY_INSTANCE); |
| |
| project.setNewProperty(EasyAntMagicNames.EASYANT_DEFAULT_IVYSETTINGS, |
| this.getClass().getResource("/org/apache/easyant/core/default-easyant-ivysettings.xml") |
| .toExternalForm()); |
| |
| project.setNewProperty(EasyAntMagicNames.EASYANT_CORE_JAR_URL, guessEasyantCoreJarUrl().toExternalForm()); |
| |
| try { |
| File userSettings = getUserEasyAntIvySettings(project); |
| URL globalSettings = getGlobalEasyAntIvySettings(project); |
| boolean isIgnoringUserIvysettings = Project.toBoolean(project |
| .getProperty(EasyAntMagicNames.IGNORE_USER_IVYSETTINGS)); |
| |
| if (userSettings.exists() && !isIgnoringUserIvysettings) { |
| project.log("loading user's easyant ivysettings file from " + userSettings.getAbsolutePath(), |
| Project.MSG_DEBUG); |
| easyantIvyConfigure.setFile(userSettings); |
| } else if (globalSettings != null) { |
| project.log("loading global easyant ivysettings file from " + globalSettings.toExternalForm(), |
| Project.MSG_DEBUG); |
| easyantIvyConfigure.setUrl(globalSettings); |
| |
| } else { |
| project.log("using easyant default ivy settings file", Project.MSG_VERBOSE); |
| String url = project.getProperty(EasyAntMagicNames.EASYANT_DEFAULT_IVYSETTINGS); |
| easyantIvyConfigure.setUrl(url); |
| } |
| } catch (MalformedURLException malformedUrl) { |
| throw new BuildException("Unable to parse easyant ivysettings from given url", malformedUrl); |
| } |
| |
| executeTask(easyantIvyConfigure, "configure-easyant", project); |
| |
| configureEasyAntOfflineRepository(project); |
| |
| IvyAntSettings easyantIvySettings = IvyInstanceHelper.getEasyAntIvyAntSettings(project); |
| |
| // FIXME: hack as ResolutionCacheManager and RepositoryCacheManger use XmlModuleDescriptorParser under the hood |
| Ivy easyantIvyInstance = easyantIvySettings.getConfiguredIvyInstance(easyantIvyConfigure); |
| |
| EasyAntRepositoryCacheManager cacheManager = new EasyAntRepositoryCacheManager("default-easyant-cache", |
| easyantIvyInstance.getSettings(), easyantIvyInstance.getSettings().getDefaultCache()); |
| easyantIvyInstance.getSettings().setDefaultRepositoryCacheManager(cacheManager); |
| |
| EasyantResolutionCacheManager resolutionCacheManager = new EasyantResolutionCacheManager(); |
| resolutionCacheManager.setBasedir(easyantIvyInstance.getSettings().getDefaultResolutionCacheBasedir()); |
| resolutionCacheManager.setSettings(easyantIvyInstance.getSettings()); |
| easyantIvyInstance.getSettings().setResolutionCacheManager(resolutionCacheManager); |
| |
| return easyantIvySettings; |
| } |
| |
| private static Method getLocalURL; |
| |
| public static synchronized URL guessEasyantCoreJarUrl() { |
| URL url = EasyAntEngine.class.getResource("/org/apache/easyant/antlib.xml"); |
| try { |
| if ("jar".equals(url.getProtocol())) { |
| return getJarUrl(url); |
| } else if ("bundleresource".equals(url.getProtocol())) { |
| URLConnection conn = url.openConnection(); |
| try { |
| if (getLocalURL == null |
| && "org.eclipse.osgi.framework.internal.core.BundleURLConnection".equals(conn.getClass() |
| .getName())) { |
| EasyAntEngine.getLocalURL = conn.getClass().getMethod("getLocalURL", (Class<?>) null); |
| getLocalURL.setAccessible(true); |
| } |
| if (getLocalURL != null && conn != null) { |
| URL localJarUrl = (URL) getLocalURL.invoke(conn, (Class<?>) null); |
| return getJarUrl(localJarUrl); |
| } |
| } catch (Throwable throwable) { |
| IOException ioe = new IOException("Cannot get jar url from Equinox OSGi bundle"); |
| ioe.initCause(throwable); |
| throw ioe; |
| } |
| } |
| } catch (IOException ioe) { |
| throw new RuntimeException("Easyant jar cannot be guessed", ioe); |
| } |
| return url; |
| } |
| |
| private static URL getJarUrl(URL url) throws IOException { |
| JarURLConnection conn = (JarURLConnection) url.openConnection(); |
| return conn.getJarFileURL(); |
| } |
| |
| /** |
| * Get user easyant-ivysettings file |
| * |
| * @param project |
| * @return the configured user easyant-ivysettings.file |
| */ |
| protected File getUserEasyAntIvySettings(Project project) { |
| // path can be specified through a property |
| String path = project.getProperty(EasyAntMagicNames.USER_EASYANT_IVYSETTINGS); |
| // if no property is set check the default location |
| if (path == null) { |
| path = PropertyHelper.getPropertyHelper(project).replaceProperties( |
| EasyAntConstants.DEFAULT_USER_EASYANT_IVYSETTINGS); |
| } |
| project.log("user's easyant-ivysettings file : " + path, Project.MSG_DEBUG); |
| return new File(path); |
| } |
| |
| /** |
| * Get global easyant-ivysettings file |
| * |
| * @param project |
| * @return the configured global easyant-ivysettings.file |
| * @throws MalformedURLException |
| */ |
| protected URL getGlobalEasyAntIvySettings(Project project) throws MalformedURLException { |
| PropertyHelper helper = PropertyHelper.getPropertyHelper(project); |
| URL path = null; |
| if (configuration.getEasyantIvySettingsFile() != null) { |
| File f = new File(helper.replaceProperties(configuration.getEasyantIvySettingsFile())); |
| path = f.toURI().toURL(); |
| } |
| if (configuration.getEasyantIvySettingsUrl() != null) { |
| path = new URL(helper.replaceProperties(configuration.getEasyantIvySettingsUrl())); |
| } |
| // path can be specified through a property |
| if (path == null && project.getProperty(EasyAntMagicNames.GLOBAL_EASYANT_IVYSETTINGS) != null) { |
| path = new URL(project.getProperty(EasyAntMagicNames.GLOBAL_EASYANT_IVYSETTINGS)); |
| } |
| // if no property is set check the default location |
| if (path == null) { |
| File defaultGlboalEasyAntIvySettings = new File( |
| helper.replaceProperties(EasyAntConstants.DEFAULT_GLOBAL_EASYANT_IVYSETTINGS)); |
| if (!defaultGlboalEasyAntIvySettings.exists()) { |
| return null; |
| } |
| path = defaultGlboalEasyAntIvySettings.toURI().toURL(); |
| } |
| project.log("global easyant-ivysettings file : " + path.toExternalForm(), Project.MSG_DEBUG); |
| return path; |
| } |
| |
| public void configurePluginService(Project project, IvyAntSettings easyantIvyInstance) { |
| pluginService = new DefaultPluginService(easyantIvyInstance); |
| String property = project.getProperty(EasyAntMagicNames.EASYANT_OFFLINE); |
| pluginService.setOfflineMode(Project.toBoolean(property)); |
| project.addReference(EasyAntMagicNames.PLUGIN_SERVICE_INSTANCE, pluginService); |
| |
| } |
| |
| /** |
| * Adds the listeners specified in the command line arguments, along with the default listener, to the specified |
| * project. |
| * |
| * @param project The project to add listeners to. Must not be <code>null</code> . |
| */ |
| protected void addBuildListeners(Project project) { |
| |
| // Add the default listener |
| project.addBuildListener(createLogger()); |
| |
| for (String className : configuration.getListeners()) { |
| BuildListener listener = (BuildListener) ClasspathUtils.newInstance(className, |
| EasyAntEngine.class.getClassLoader(), BuildListener.class); |
| project.setProjectReference(listener); |
| |
| project.addBuildListener(listener); |
| } |
| } |
| |
| /** |
| * Creates the InputHandler and adds it to the project. |
| * |
| * @param project the project instance. |
| * @throws BuildException if a specified InputHandler implementation could not be loaded. |
| */ |
| protected void addInputHandler(Project project) { |
| InputHandler handler; |
| |
| if (configuration.getInputHandlerClassname() == null) { |
| handler = new DefaultInputHandler(); |
| } else { |
| handler = (InputHandler) ClasspathUtils.newInstance(configuration.getInputHandlerClassname(), |
| Main.class.getClassLoader(), InputHandler.class); |
| project.setProjectReference(handler); |
| } |
| project.setInputHandler(handler); |
| } |
| |
| /** |
| * Creates the default build logger for sending build events to the ant log. |
| * |
| * @return the logger instance for this build. |
| */ |
| protected BuildLogger createLogger() { |
| BuildLogger logger; |
| if (configuration.getLoggerClassname() != null) { |
| try { |
| logger = (BuildLogger) ClasspathUtils.newInstance(configuration.getLoggerClassname(), |
| EasyAntEngine.class.getClassLoader(), BuildLogger.class); |
| } catch (BuildException e) { |
| throw new RuntimeException("The specified logger class " + configuration.getLoggerClassname() |
| + " could not be used because " + e.getMessage(), e); |
| } |
| } else { |
| logger = new DefaultEasyAntLogger(); |
| } |
| |
| logger.setMessageOutputLevel(configuration.getMsgOutputLevel()); |
| logger.setOutputPrintStream(configuration.getOut()); |
| logger.setErrorPrintStream(configuration.getErr()); |
| logger.setEmacsMode(configuration.isEmacsMode()); |
| |
| return logger; |
| } |
| |
| /** |
| * Search parent directories for the build file. |
| * <p/> |
| * Takes the given target as a suffix to append to each parent directory in search of a build file. Once the root of |
| * the file-system has been reached an exception is thrown. |
| * |
| * @param start Leaf directory of search. Must not be <code>null</code>. |
| * @param suffix Suffix filename to look for in parents. Must not be <code>null</code>. |
| * @return A handle to the build file if one is found |
| * @throws BuildException if no build file is found |
| */ |
| protected File findBuildModule(String start, String suffix) throws BuildException { |
| if (configuration.getMsgOutputLevel() >= Project.MSG_INFO) { |
| System.out.println("Searching for " + suffix + " ..."); |
| } |
| |
| File parent = new File(new File(start).getAbsolutePath()); |
| File file = new File(parent, suffix); |
| |
| // check if the target file exists in the current directory |
| while (!file.exists()) { |
| // change to parent directory |
| parent = parent.getParentFile(); |
| |
| // if parent is null, then we are at the root of the fs, |
| // complain that we can't find the build file. |
| if (parent == null) { |
| throw new BuildException("Could not locate a build file!"); |
| } |
| |
| // refresh our file handle |
| file = new File(parent, suffix); |
| } |
| |
| return file; |
| } |
| |
| |
| /** |
| * configure easyant (listeners, inputhandlers, proxy, easyantIvyInstance, systems plugins etc...) |
| * |
| * @param project a project to configure |
| */ |
| public void configureEasyAnt(Project project) { |
| |
| project.setCoreLoader(configuration.getCoreLoader()); |
| |
| addBuildListeners(project); |
| addInputHandler(project); |
| |
| // set the thread priorities |
| if (configuration.getThreadPriority() != null) { |
| try { |
| project.log("Setting Ant's thread priority to " + configuration.getThreadPriority(), |
| Project.MSG_VERBOSE); |
| Thread.currentThread().setPriority(configuration.getThreadPriority()); |
| } catch (SecurityException swallowed) { |
| // we cannot set the priority here. |
| project.log("A security manager refused to set the -nice value"); |
| } |
| } |
| |
| project.setKeepGoingMode(configuration.isKeepGoingMode()); |
| if (configuration.isProxy()) { |
| // proxy setup if enabledcoreLoader |
| ProxySetup proxySetup = new ProxySetup(project); |
| proxySetup.enableProxies(); |
| } |
| |
| project.setName("EasyAnt"); |
| |
| try { |
| project.init(); |
| project.addReference(EasyAntMagicNames.EASYANT_ENGINE_REF, this); |
| |
| // set user-define properties |
| Enumeration<?> properties = configuration.getDefinedProps().propertyNames(); |
| while (properties.hasMoreElements()) { |
| String arg = (String) properties.nextElement(); |
| String value = (String) configuration.getDefinedProps().get(arg); |
| project.setUserProperty(arg, value); |
| } |
| |
| project.setUserProperty(EasyAntMagicNames.EASYANT_OFFLINE, Boolean.toString(configuration.isOffline())); |
| |
| ProjectUtils.configureProjectHelper(project); |
| |
| IvyAntSettings easyantIvySettings = configureEasyAntIvyInstance(project); |
| configurePluginService(project, easyantIvySettings); |
| |
| // Profile |
| if (!configuration.getActiveBuildConfigurations().isEmpty()) { |
| String buildConfigurations = null; |
| for (String conf : configuration.getActiveBuildConfigurations()) { |
| if (buildConfigurations == null) { |
| buildConfigurations = conf; |
| } else { |
| buildConfigurations = buildConfigurations + "," + conf; |
| } |
| |
| } |
| project.log("Active build configurations : " + buildConfigurations, Project.MSG_INFO); |
| project.setProperty(EasyAntMagicNames.ACTIVE_BUILD_CONFIGURATIONS, buildConfigurations); |
| } |
| loadSystemPlugins(project, true); |
| } catch (RuntimeException exc) { |
| fireBuildFinished(project, exc); |
| throw exc; |
| } |
| } |
| |
| /** |
| * Load an easyant project and resolve extension points |
| * |
| * @param project |
| */ |
| public void loadProject(Project project) { |
| try { |
| locateBuildModuleAndBuildFile(project); |
| |
| if (configuration.getBuildModule() != null || configuration.getBuildFile() != null) { |
| LoadModule lm = new LoadModule(); |
| lm.setBuildModule(configuration.getBuildModule()); |
| lm.setBuildFile(configuration.getBuildFile()); |
| executeTask(lm, "load-module", project); |
| } |
| ProjectUtils.getConfiguredProjectHelper(project).resolveExtensionOfAttributes(project); |
| } catch (RuntimeException exc) { |
| fireBuildFinished(project, exc); |
| throw exc; |
| } |
| |
| } |
| |
| private void fireBuildFinished(Project project, Throwable error) { |
| try { |
| project.fireBuildFinished(error); |
| } catch (Throwable t) { |
| // yes, I know it is bad style to catch Throwable, |
| // but if we don't, we lose valuable information |
| System.err.println("Caught an exception while logging the" + " end of the build. Exception was:"); |
| t.printStackTrace(); |
| if (error != null) { |
| System.err.println("There has been an error prior to" + " that:"); |
| error.printStackTrace(); |
| } |
| throw new BuildException(t); |
| } |
| } |
| |
| public void loadSystemPlugins(Project project, boolean isRootProject) { |
| if (isRootProject && !configuration.getSystemPlugins().isEmpty()) { |
| project.log("Loading System Plugins..."); |
| } |
| for (PluginDescriptor systemPlugin : configuration.getSystemPlugins()) { |
| if (isRootProject && InheritableScope.BOTH == systemPlugin.getInheritScope() |
| || systemPlugin.isInheritable()) { |
| // import/include system plugin |
| Import importTask = new Import(); |
| importTask.setMrid(systemPlugin.getMrid()); |
| importTask.setOrganisation(systemPlugin.getOrganisation()); |
| importTask.setModule(systemPlugin.getModule()); |
| importTask.setRevision(systemPlugin.getRevision()); |
| importTask.setAs(systemPlugin.getAs()); |
| importTask.setMode(systemPlugin.getMode()); |
| importTask.setMandatory(systemPlugin.isMandatory()); |
| executeTask(importTask, "configure-system-plugins", project); |
| } |
| } |
| } |
| |
| private void locateBuildModuleAndBuildFile(Project project) { |
| File buildModule = configuration.getBuildModule(); |
| File buildFile = configuration.getBuildFile(); |
| |
| if (project.getProperty("project.basedir") != null) { |
| project.setBaseDir(new File(project.getProperty("project.basedir"))); |
| } |
| |
| if (buildModule == null) { |
| buildModule = new File(project.getBaseDir(), EasyAntConstants.DEFAULT_BUILD_MODULE); |
| } |
| |
| if (!buildModule.exists() && configuration.isBuildModuleLookupEnabled()) { |
| buildModule = findBuildModule(System.getProperty("user.dir"), buildModule.toString()); |
| } |
| |
| // calculate buildFile location based on buildModule directory |
| if (buildModule.exists() && buildFile == null) { |
| buildFile = new File(buildModule.getParentFile(), EasyAntConstants.DEFAULT_BUILD_FILE); |
| } |
| |
| if (buildFile == null && configuration.isBuildModuleLookupEnabled()) { |
| buildFile = findBuildModule(System.getProperty("user.dir"), EasyAntConstants.DEFAULT_BUILD_FILE); |
| } |
| |
| // Normalize buildFile for re-import detection |
| if (buildModule != null) { |
| buildModule = FileUtils.getFileUtils().normalize(buildModule.getAbsolutePath()); |
| project.setNewProperty(EasyAntMagicNames.EASYANT_FILE, buildModule.getAbsolutePath()); |
| |
| } |
| |
| if (buildFile != null) { |
| buildFile = FileUtils.getFileUtils().normalize(buildFile.getAbsolutePath()); |
| project.setNewProperty(MagicNames.ANT_FILE, buildFile.getAbsolutePath()); |
| |
| } |
| |
| configuration.setBuildFile(buildFile); |
| configuration.setBuildModule(buildModule); |
| } |
| |
| /** |
| * Configure easyant offline repository If offline mode is enabled, it will acts as dictator resolver |
| * |
| * @param project {@link Project} where repositories will be configured |
| */ |
| private void configureEasyAntOfflineRepository(Project project) { |
| // assign default value if not already set |
| project.setProperty(EasyAntMagicNames.OFFLINE_EASYANT_RESOLVER, |
| EasyAntConstants.DEFAULT_OFFLINE_EASYANT_RESOLVER); |
| project.setProperty(EasyAntMagicNames.OFFLINE_BASE_DIRECTORY, project.getBaseDir().getAbsolutePath() |
| + "/offline/"); |
| |
| ConfigureBuildScopedRepository easyantOfflineRepository = new ConfigureBuildScopedRepository(); |
| easyantOfflineRepository.setGenerateWrapperResoler(false); |
| easyantOfflineRepository.setName(project.getProperty(EasyAntMagicNames.OFFLINE_EASYANT_RESOLVER)); |
| easyantOfflineRepository.setDictator(Project.toBoolean(project.getProperty(EasyAntMagicNames.EASYANT_OFFLINE))); |
| easyantOfflineRepository.setSettingsRef(IvyInstanceHelper.buildEasyAntIvyReference(project)); |
| easyantOfflineRepository.setTarget(project.getProperty(EasyAntMagicNames.OFFLINE_BASE_DIRECTORY)); |
| executeTask(easyantOfflineRepository, "configure-offline-easyant-resolver", project); |
| } |
| |
| private void executeTask(Task task, String operationName, Project project) { |
| Location location = new Location(ProjectUtils.emulateMainScript(project).getAbsolutePath()); |
| task.setLocation(location); |
| task.setOwningTarget(ProjectUtils.createTopLevelTarget()); |
| task.setProject(project); |
| task.setTaskName(EasyAntConstants.EASYANT_TASK_NAME + "-" + operationName); |
| task.execute(); |
| |
| } |
| |
| /** |
| * this method run the build process |
| * |
| * @throws BuildException |
| */ |
| public void doBuild() throws BuildException { |
| final Project project = new Project(); |
| configureEasyAnt(project); |
| loadProject(project); |
| doBuild(project); |
| |
| } |
| |
| public void doBuild(final Project project) { |
| project.fireBuildStarted(); |
| |
| Throwable error = null; |
| |
| try { |
| |
| PrintStream savedErr = System.err; |
| PrintStream savedOut = System.out; |
| InputStream savedIn = System.in; |
| |
| // use a system manager that prevents from System.exit() |
| SecurityManager oldsm; |
| oldsm = System.getSecurityManager(); |
| |
| // SecurityManager can not be installed here for backwards |
| // compatibility reasons (PD). Needs to be loaded prior to |
| // ant class if we are going to implement it. |
| // System.setSecurityManager(new NoExitSecurityManager()); |
| try { |
| if (configuration.isAllowInput()) { |
| project.setDefaultInputStream(System.in); |
| } |
| System.setIn(new DemuxInputStream(project)); |
| System.setOut(new PrintStream(new DemuxOutputStream(project, false))); |
| System.setErr(new PrintStream(new DemuxOutputStream(project, true))); |
| |
| // make sure that we have a target to execute |
| if (configuration.getTargets().isEmpty() && project.getDefaultTarget() != null) { |
| configuration.getTargets().add(project.getDefaultTarget()); |
| } |
| project.executeTargets(new Vector<String>(configuration.getTargets())); |
| } finally { |
| // put back the original security manager |
| // The following will never eval to true. (PD) |
| if (oldsm != null) { |
| System.setSecurityManager(oldsm); |
| } |
| |
| System.setOut(savedOut); |
| System.setErr(savedErr); |
| System.setIn(savedIn); |
| } |
| } catch (RuntimeException exc) { |
| error = exc; |
| throw exc; |
| } catch (Error e) { |
| error = e; |
| throw e; |
| } finally { |
| fireBuildFinished(project, error); |
| } |
| if (configuration.isShowMemoryDetails() || configuration.getMsgOutputLevel() >= Project.MSG_VERBOSE) { |
| ProjectUtils.printMemoryDetails(project); |
| } |
| } |
| |
| /** |
| * This is a static method used to run build process |
| * |
| * @param eaConfig an easyant configuration |
| * @throws BuildException |
| */ |
| public static void runBuild(EasyAntConfiguration eaConfig) throws BuildException { |
| EasyAntEngine eaEngine = new EasyAntEngine(eaConfig); |
| eaEngine.doBuild(); |
| } |
| |
| /** |
| * This is a static method used to configure and load an existing project |
| * |
| * @param project a given project |
| * @param eaConfiguration an easyant configuration |
| * @return configured project |
| * @throws BuildException |
| */ |
| public static Project configureAndLoadProject(Project project, EasyAntConfiguration eaConfiguration) |
| throws BuildException { |
| EasyAntEngine eaEngine = new EasyAntEngine(eaConfiguration); |
| eaEngine.configureEasyAnt(project); |
| eaEngine.loadProject(project); |
| return project; |
| } |
| |
| /** |
| * Return the configured plugin service instance |
| * |
| * @return the configured plugin service instance |
| */ |
| public PluginService getPluginService() { |
| // hack for IDE integration |
| if (pluginService == null) { |
| Project project = new Project(); |
| project.setCoreLoader(configuration.getCoreLoader()); |
| Enumeration<?> e = configuration.getDefinedProps().keys(); |
| while (e.hasMoreElements()) { |
| String arg = (String) e.nextElement(); |
| String value = (String) configuration.getDefinedProps().get(arg); |
| project.setUserProperty(arg, value); |
| } |
| project.setName("EasyAnt"); |
| // not sure we need to invoke init here |
| project.init(); |
| IvyAntSettings ivyAntSettings = configureEasyAntIvyInstance(project); |
| configurePluginService(project, ivyAntSettings); |
| } |
| return pluginService; |
| } |
| |
| /** |
| * Cache of the EasyAnt version information when it has been loaded. |
| */ |
| private static String easyantVersion = null; |
| |
| /** |
| * Returns the EasyAnt 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 String getEasyAntVersion() { |
| |
| if (easyantVersion == null) { |
| InputStream in = null; |
| |
| try { |
| Properties props = new Properties(); |
| in = Main.class.getResourceAsStream("/META-INF/version.properties"); |
| if (in == null) { |
| throw new BuildException("Could not load the version information."); |
| |
| } |
| props.load(in); |
| |
| easyantVersion = "EasyAnt 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 easyantVersion; |
| } |
| |
| } |
