| /* |
| * The Apache Software License, Version 1.1 |
| * |
| * Copyright (c) 2002 The Apache Software Foundation. All rights |
| * reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in |
| * the documentation and/or other materials provided with the |
| * distribution. |
| * |
| * 3. The end-user documentation included with the redistribution, if |
| * any, must include the following acknowlegement: |
| * "This product includes software developed by the |
| * Apache Software Foundation (http://www.apache.org/)." |
| * Alternately, this acknowlegement may appear in the software itself, |
| * if and wherever such third-party acknowlegements normally appear. |
| * |
| * 4. The names "The Jakarta Project", "Ant", and "Apache Software |
| * Foundation" must not be used to endorse or promote products derived |
| * from this software without prior written permission. For written |
| * permission, please contact apache@apache.org. |
| * |
| * 5. Products derived from this software may not be called "Apache" |
| * nor may "Apache" appear in their names without prior written |
| * permission of the Apache Group. |
| * |
| * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED |
| * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR |
| * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF |
| * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, |
| * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT |
| * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
| * SUCH DAMAGE. |
| * ==================================================================== |
| * |
| * This software consists of voluntary contributions made by many |
| * individuals on behalf of the Apache Software Foundation. For more |
| * information on the Apache Software Foundation, please see |
| * <http://www.apache.org/>. |
| */ |
| package org.apache.ant.antcore.execution; |
| import java.io.File; |
| import java.net.URL; |
| import java.net.MalformedURLException; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Map; |
| import java.util.StringTokenizer; |
| import java.util.List; |
| import java.util.ArrayList; |
| import org.apache.ant.antcore.config.AntConfig; |
| import org.apache.ant.common.antlib.Task; |
| import org.apache.ant.common.event.BuildListener; |
| import org.apache.ant.common.event.MessageLevel; |
| import org.apache.ant.common.model.BuildElement; |
| import org.apache.ant.common.model.Project; |
| import org.apache.ant.common.model.Target; |
| import org.apache.ant.common.service.ComponentService; |
| import org.apache.ant.common.service.DataService; |
| import org.apache.ant.common.service.EventService; |
| import org.apache.ant.common.service.ExecService; |
| import org.apache.ant.common.service.FileService; |
| import org.apache.ant.common.service.InputService; |
| import org.apache.ant.common.service.MagicProperties; |
| import org.apache.ant.common.util.DemuxOutputReceiver; |
| import org.apache.ant.common.util.ExecutionException; |
| import org.apache.ant.common.util.FileUtils; |
| import org.apache.ant.init.InitConfig; |
| |
| /** |
| * An Frame maintains the state of a project during an execution. The Frame |
| * contains the data values set by Ant tasks as they are executed, including |
| * task definitions, property values, etc. |
| * |
| * @author Conor MacNeill |
| * @created 14 January 2002 |
| */ |
| public class Frame implements DemuxOutputReceiver { |
| /** the base dir of the project */ |
| private File baseDir; |
| |
| /** The Project that this execution frame is processing */ |
| private Project project = null; |
| |
| /** The referenced frames corresponding to the referenced projects */ |
| private Map referencedFrames = new HashMap(); |
| |
| /** |
| * The property overrides for the referenced frames. This map is indexed |
| * by the reference names of the frame. Each entry is another Map of |
| * property values indexed by their relative name. |
| */ |
| private Map overrides = new HashMap(); |
| |
| /** |
| * The context of this execution. This contains all data object's created |
| * by tasks that have been executed |
| */ |
| private Map dataValues = new HashMap(); |
| |
| /** |
| * Ant's initialization configuration with information on the location of |
| * Ant and its libraries. |
| */ |
| private InitConfig initConfig; |
| |
| /** BuildEvent support used to fire events and manage listeners */ |
| private BuildEventSupport eventSupport = new BuildEventSupport(); |
| |
| /** |
| * The services map is a map of service interface classes to instances |
| * which provide the service. |
| */ |
| private Map services = new HashMap(); |
| |
| /** |
| * The configuration to be used in this execution of Ant. It is formed |
| * from the system, user and any runtime configs. |
| */ |
| private AntConfig config; |
| |
| /** |
| * The Data Service instance used by the frame for data management |
| */ |
| private DataService dataService; |
| |
| /** The execution file service instance */ |
| private FileService fileService; |
| |
| /** |
| * the Component Manager used to manage the importing of library |
| * components from the Ant libraries |
| */ |
| private ComponentManager componentManager; |
| |
| /** The core's execution Service */ |
| private CoreExecService execService; |
| |
| |
| /** |
| * Create an Execution Frame for the given project |
| * |
| * @param config the user config to use for this execution of Ant |
| * @param initConfig Ant's initialisation config |
| * @exception ExecutionException if a component of the library cannot be |
| * imported |
| */ |
| protected Frame(InitConfig initConfig, |
| AntConfig config) throws ExecutionException { |
| this.config = config; |
| this.initConfig = initConfig; |
| } |
| |
| |
| /** |
| * Replace ${} style constructions in the given value with the string |
| * value of the corresponding data values in the frame |
| * |
| * @param value the string to be scanned for property references. |
| * @return the string with all property references replaced |
| * @exception ExecutionException if any of the properties do not exist |
| */ |
| protected String replacePropertyRefs(String value) |
| throws ExecutionException { |
| return dataService.replacePropertyRefs(value); |
| } |
| |
| |
| /** |
| * Sets the Project of the Frame |
| * |
| * @param project The new Project value |
| * @exception ExecutionException if any required sub-frames cannot be |
| * created and configured |
| */ |
| protected void setProject(Project project) throws ExecutionException { |
| this.project = project; |
| referencedFrames.clear(); |
| } |
| |
| |
| /** |
| * get the name of the project associated with this frame. |
| * |
| * @return the project's name |
| */ |
| protected String getProjectName() { |
| if (project != null) { |
| return project.getName(); |
| } |
| return null; |
| } |
| |
| |
| /** |
| * Set a value in this frame or any of its imported frames. |
| * |
| * @param name the name of the value |
| * @param value the actual value |
| * @param mutable if true, existing values can be changed |
| * @exception ExecutionException if the value name is invalid |
| */ |
| protected void setDataValue(String name, Object value, boolean mutable) |
| throws ExecutionException { |
| Frame frame = getContainingFrame(name); |
| |
| if (frame == null) { |
| setOverrideProperty(name, value, mutable); |
| return; |
| } |
| |
| if (frame == this) { |
| if (dataValues.containsKey(name) && !mutable) { |
| log("Ignoring oveeride for data value " + name, |
| MessageLevel.MSG_VERBOSE); |
| } else { |
| dataValues.put(name, value); |
| } |
| } else { |
| frame.setDataValue(getNameInFrame(name), value, mutable); |
| } |
| } |
| |
| /** |
| * When a frame has not yet been referenced, this method is used |
| * to set the initial properties for the frame when it is introduced. |
| * |
| * @param name the name of the value |
| * @param value the actual value |
| * @param mutable if true, existing values can be changed |
| * @exception ExecutionException if attempting to override a property in |
| * the current frame. |
| */ |
| private void setOverrideProperty(String name, Object value, |
| boolean mutable) |
| throws ExecutionException { |
| int refIndex = name.indexOf(Project.REF_DELIMITER); |
| if (refIndex == -1) { |
| throw new ExecutionException("Property overrides can only be set" |
| + " for properties in referenced projects - not " |
| + name); |
| } |
| |
| String firstFrameName = name.substring(0, refIndex); |
| |
| String relativeName |
| = name.substring(refIndex + Project.REF_DELIMITER.length()); |
| |
| Map frameOverrides = (Map) overrides.get(firstFrameName); |
| if (frameOverrides == null) { |
| frameOverrides = new HashMap(); |
| overrides.put(firstFrameName, frameOverrides); |
| } |
| |
| if (mutable || !frameOverrides.containsKey(relativeName)) { |
| frameOverrides.put(relativeName, value); |
| } |
| } |
| |
| /** |
| * Get a value which exists in the frame property overrides awaiting |
| * the frame to be introduced. |
| * |
| * @param name the name of the value |
| * @return the value of the property or null if the property does not |
| * exist. |
| * @exception ExecutionException if attempting to get an override in |
| * the current frame. |
| */ |
| private Object getOverrideProperty(String name) throws ExecutionException { |
| int refIndex = name.indexOf(Project.REF_DELIMITER); |
| if (refIndex == -1) { |
| throw new ExecutionException("Property overrides can only be" |
| + " returned for properties in referenced projects - not " |
| + name); |
| } |
| |
| String firstFrameName = name.substring(0, refIndex); |
| |
| String relativeName |
| = name.substring(refIndex + Project.REF_DELIMITER.length()); |
| |
| Map frameOverrides = (Map) overrides.get(firstFrameName); |
| if (frameOverrides == null) { |
| return null; |
| } |
| |
| return frameOverrides.get(relativeName); |
| } |
| |
| /** |
| * Get a value which exists in the frame property overrides awaiting |
| * the frame to be introduced. |
| * |
| * @param name the name of the value |
| * @return the value of the property or null if the property does not |
| * exist. |
| * @exception ExecutionException if attempting to check an override in |
| * the current frame. |
| */ |
| private boolean isOverrideSet(String name) throws ExecutionException { |
| int refIndex = name.indexOf(Project.REF_DELIMITER); |
| if (refIndex == -1) { |
| throw new ExecutionException("Property overrides can only be" |
| + " returned for properties in referenced projects - not " |
| + name); |
| } |
| |
| String firstFrameName = name.substring(0, refIndex); |
| |
| String relativeName |
| = name.substring(refIndex + Project.REF_DELIMITER.length()); |
| |
| Map frameOverrides = (Map) overrides.get(firstFrameName); |
| if (frameOverrides == null) { |
| return false; |
| } |
| |
| return frameOverrides.containsKey(relativeName); |
| } |
| |
| |
| /** |
| * Set the initial properties to be used when the frame starts execution |
| * |
| * @param properties a Map of named properties which may in fact be any |
| * object |
| * @exception ExecutionException if the properties cannot be set |
| */ |
| protected void setInitialProperties(Map properties) |
| throws ExecutionException { |
| if (properties != null) { |
| addProperties(properties); |
| } |
| |
| // add in system properties |
| addProperties(System.getProperties()); |
| } |
| |
| |
| /** |
| * Set the values of various magic properties |
| * |
| * @exception ExecutionException if the properties cannot be set |
| */ |
| protected void setMagicProperties() throws ExecutionException { |
| URL antHomeURL = initConfig.getAntHome(); |
| String antHomeString = null; |
| |
| if (antHomeURL.getProtocol().equals("file")) { |
| File antHome = new File(antHomeURL.getFile()); |
| |
| antHomeString = antHome.getAbsolutePath(); |
| } else { |
| antHomeString = antHomeURL.toString(); |
| } |
| setDataValue(MagicProperties.ANT_HOME, antHomeString, true); |
| } |
| |
| |
| /** |
| * Get a definition from a referenced frame |
| * |
| * @param definitionName the name of the definition relative to this frame |
| * @return the appropriate import info object from the referenced frame's |
| * imports |
| * @exception ExecutionException if the referenced definition cannot be |
| * found |
| */ |
| protected ImportInfo getReferencedDefinition(String definitionName) |
| throws ExecutionException { |
| Frame containingFrame = getContainingFrame(definitionName); |
| String localName = getNameInFrame(definitionName); |
| |
| if (containingFrame == null) { |
| throw new ExecutionException("There is no project corresponding " |
| + "to the name \"" + definitionName + "\""); |
| } |
| if (containingFrame == this) { |
| return componentManager.getDefinition(localName); |
| } else { |
| return containingFrame.getReferencedDefinition(localName); |
| } |
| } |
| |
| |
| /** |
| * Gets the project model this frame is working with |
| * |
| * @return the project model |
| */ |
| protected Project getProject() { |
| return project; |
| } |
| |
| |
| /** |
| * Get all the properties from the frame and any references frames. This |
| * is an expensive operation since it must clone all of the property |
| * stores in all frames |
| * |
| * @return a Map containing the frames properties indexed by their full |
| * name. |
| */ |
| protected Map getAllProperties() { |
| Map allProperties = new HashMap(dataValues); |
| Iterator i = referencedFrames.keySet().iterator(); |
| |
| while (i.hasNext()) { |
| String refName = (String) i.next(); |
| Frame refFrame = getReferencedFrame(refName); |
| Map refProperties = refFrame.getAllProperties(); |
| Iterator j = refProperties.keySet().iterator(); |
| |
| while (j.hasNext()) { |
| String name = (String) j.next(); |
| Object value = refProperties.get(name); |
| |
| allProperties.put(refName + Project.REF_DELIMITER + name, |
| value); |
| } |
| } |
| |
| return allProperties; |
| } |
| |
| |
| /** |
| * Get the Ant initialization configuration for this frame. |
| * |
| * @return Ant's initialization configuration |
| */ |
| protected InitConfig getInitConfig() { |
| return initConfig; |
| } |
| |
| |
| /** |
| * Get the config instance being used by this frame. |
| * |
| * @return the config associated with this frame. |
| */ |
| protected AntConfig getConfig() { |
| return config; |
| } |
| |
| |
| /** |
| * Get the core's implementation of the given service interface. |
| * |
| * @param serviceInterfaceClass the service interface for which an |
| * implementation is require |
| * @return the core's implementation of the service interface |
| * @exception ExecutionException if the core does not provide an |
| * implementatin of the requested interface |
| */ |
| protected Object getCoreService(Class serviceInterfaceClass) |
| throws ExecutionException { |
| Object service = services.get(serviceInterfaceClass); |
| |
| if (service == null) { |
| throw new ExecutionException("No service of interface class " |
| + serviceInterfaceClass); |
| } |
| return service; |
| } |
| |
| |
| /** |
| * Get the EventSupport instance for this frame. This tracks the build |
| * listeners on this frame |
| * |
| * @return the EventSupport instance |
| */ |
| protected BuildEventSupport getEventSupport() { |
| return eventSupport; |
| } |
| |
| |
| /** |
| * Gets the baseDir of the Frame |
| * |
| * @return the baseDir value |
| */ |
| protected File getBaseDir() { |
| return baseDir; |
| } |
| |
| |
| /** |
| * Get a referenced frame by its reference name |
| * |
| * @param referenceName the name under which the frame was imported. |
| * @return the Frame asscociated with the given reference name or null if |
| * there is no such project. |
| */ |
| protected Frame getReferencedFrame(String referenceName) { |
| return (Frame) referencedFrames.get(referenceName); |
| } |
| |
| |
| /** |
| * Get the frames representing referenced projects. |
| * |
| * @return an iterator which returns the referenced ExeuctionFrames.. |
| */ |
| protected Iterator getReferencedFrames() { |
| return referencedFrames.values().iterator(); |
| } |
| |
| |
| /** |
| * Get the name of an object in its frame |
| * |
| * @param fullname The name of the object |
| * @return the name of the object within its containing frame |
| */ |
| protected String getNameInFrame(String fullname) { |
| int index = fullname.lastIndexOf(Project.REF_DELIMITER); |
| |
| if (index == -1) { |
| return fullname; |
| } |
| return fullname.substring(index + Project.REF_DELIMITER.length()); |
| } |
| |
| |
| /** |
| * Get a value from this frame or any imported frame |
| * |
| * @param name the name of the data value - may contain reference |
| * delimiters |
| * @return the data value fetched from the appropriate frame |
| * @exception ExecutionException if the value is not defined |
| */ |
| protected Object getDataValue(String name) throws ExecutionException { |
| Frame frame = getContainingFrame(name); |
| |
| if (frame == null) { |
| return getOverrideProperty(name); |
| } |
| if (frame == this) { |
| return dataValues.get(name); |
| } else { |
| return frame.getDataValue(getNameInFrame(name)); |
| } |
| } |
| |
| |
| /** |
| * Indicate if a data value has been set |
| * |
| * @param name the name of the data value - may contain reference |
| * delimiters |
| * @return true if the value exists |
| * @exception ExecutionException if the containing frame for the value |
| * does not exist |
| */ |
| protected boolean isDataValueSet(String name) throws ExecutionException { |
| Frame frame = getContainingFrame(name); |
| |
| if (frame == null) { |
| return isOverrideSet(name); |
| } |
| if (frame == this) { |
| return dataValues.containsKey(name); |
| } else { |
| return frame.isDataValueSet(getNameInFrame(name)); |
| } |
| } |
| |
| |
| /** |
| * Get the execution frame which contains, directly, the named element |
| * where the name is relative to this frame |
| * |
| * @param elementName The name of the element |
| * @return the execution frame for the project that contains the given |
| * target |
| */ |
| protected Frame getContainingFrame(String elementName) { |
| int index = elementName.lastIndexOf(Project.REF_DELIMITER); |
| |
| if (index == -1) { |
| return this; |
| } |
| |
| Frame currentFrame = this; |
| String relativeName = elementName.substring(0, index); |
| StringTokenizer tokenizer |
| = new StringTokenizer(relativeName, Project.REF_DELIMITER); |
| |
| while (tokenizer.hasMoreTokens()) { |
| String refName = tokenizer.nextToken(); |
| |
| currentFrame = currentFrame.getReferencedFrame(refName); |
| if (currentFrame == null) { |
| return null; |
| } |
| } |
| |
| return currentFrame; |
| } |
| |
| |
| /** |
| * Add a collection of properties to this frame |
| * |
| * @param properties the collection of property values, indexed by their |
| * names |
| * @exception ExecutionException if the frame cannot be created. |
| */ |
| protected void addProperties(Map properties) throws ExecutionException { |
| for (Iterator i = properties.keySet().iterator(); i.hasNext();) { |
| String name = (String) i.next(); |
| Object value = properties.get(name); |
| |
| setDataValue(name, value, false); |
| } |
| } |
| |
| /** |
| * Create a project reference. |
| * |
| * @param name the name under which the project will be |
| * referenced. |
| * @param project the project model. |
| * @param initialData the project's initial data load. |
| * @exception ExecutionException if the project cannot be referenced. |
| */ |
| protected void createProjectReference(String name, Project project, |
| Map initialData) |
| throws ExecutionException { |
| Frame referencedFrame = createFrame(project); |
| |
| if (initialData != null) { |
| referencedFrame.setInitialProperties(initialData); |
| } |
| |
| // does the frame have any overrides? |
| Map initialProperties = (Map) overrides.get(name); |
| if (initialProperties != null) { |
| referencedFrame.setInitialProperties(initialProperties); |
| overrides.remove(name); |
| } |
| |
| |
| |
| referencedFrames.put(name, referencedFrame); |
| referencedFrame.initialize(); |
| } |
| |
| /** |
| * Create a new frame for a given project |
| * |
| * @param project the project model the frame will deal with |
| * @return an Frame ready to build the project |
| * @exception ExecutionException if the frame cannot be created. |
| */ |
| protected Frame createFrame(Project project) |
| throws ExecutionException { |
| Frame newFrame |
| = new Frame(initConfig, config); |
| |
| newFrame.setProject(project); |
| for (Iterator j = eventSupport.getListeners(); j.hasNext();) { |
| BuildListener listener = (BuildListener) j.next(); |
| |
| newFrame.addBuildListener(listener); |
| } |
| |
| return newFrame; |
| } |
| |
| |
| /** |
| * Log a message as a build event |
| * |
| * @param message the message to be logged |
| * @param level the priority level of the message |
| */ |
| protected void log(String message, int level) { |
| eventSupport.fireMessageLogged(project, message, level); |
| } |
| |
| |
| /** |
| * Add a build listener to this execution frame |
| * |
| * @param listener the listener to be added to the frame |
| */ |
| protected void addBuildListener(BuildListener listener) { |
| for (Iterator i = getReferencedFrames(); i.hasNext();) { |
| Frame referencedFrame = (Frame) i.next(); |
| |
| referencedFrame.addBuildListener(listener); |
| } |
| eventSupport.addBuildListener(listener); |
| } |
| |
| |
| /** |
| * Remove a build listener from the execution |
| * |
| * @param listener the listener to be removed |
| */ |
| protected void removeBuildListener(BuildListener listener) { |
| for (Iterator i = getReferencedFrames(); i.hasNext();) { |
| Frame subFrame = (Frame) i.next(); |
| |
| subFrame.removeBuildListener(listener); |
| } |
| eventSupport.removeBuildListener(listener); |
| } |
| |
| |
| /** |
| * Run the given list of targets |
| * |
| * @param targets a list of target names which are to be evaluated |
| * @exception ExecutionException if there is a problem in the build |
| */ |
| protected void runBuild(List targets) throws ExecutionException { |
| initialize(); |
| if (targets.isEmpty()) { |
| // we just execute the default target if any |
| String defaultTarget = project.getDefaultTarget(); |
| |
| if (defaultTarget != null) { |
| log("Executing default target: " + defaultTarget, |
| MessageLevel.MSG_DEBUG); |
| executeTarget(defaultTarget); |
| } |
| } else { |
| for (Iterator i = targets.iterator(); i.hasNext();) { |
| String targetName = (String) i.next(); |
| |
| log("Executing target: " + targetName, MessageLevel.MSG_DEBUG); |
| executeTarget(targetName); |
| } |
| } |
| } |
| |
| |
| |
| /** |
| * Given a fully qualified target name, this method returns the fully |
| * qualified name of the project |
| * |
| * @param fullTargetName the full qualified target name |
| * @return the full name of the containing project |
| */ |
| private String getFullProjectName(String fullTargetName) { |
| int index = fullTargetName.lastIndexOf(Project.REF_DELIMITER); |
| if (index == -1) { |
| return null; |
| } |
| |
| return fullTargetName.substring(0, index); |
| } |
| |
| /** |
| * Flatten the dependencies to the given target |
| * |
| * @param flattenedList the List of targets that must be executed before |
| * the given target |
| * @param fullTargetName the fully qualified name of the target |
| * @exception ExecutionException if the given target does not exist in the |
| * project hierarchy |
| */ |
| private void flattenDependency(List flattenedList, String fullTargetName) |
| throws ExecutionException { |
| if (flattenedList.contains(fullTargetName)) { |
| return; |
| } |
| String fullProjectName = getFullProjectName(fullTargetName); |
| Frame frame = getContainingFrame(fullTargetName); |
| String localTargetName = getNameInFrame(fullTargetName); |
| Target target = frame.getProject().getTarget(localTargetName); |
| if (target == null) { |
| throw new ExecutionException("Target " + fullTargetName |
| + " does not exist"); |
| } |
| for (Iterator i = target.getDependencies(); i.hasNext();) { |
| String localDependencyName = (String) i.next(); |
| String fullDependencyName = localDependencyName; |
| if (fullProjectName != null) { |
| fullDependencyName = fullProjectName + Project.REF_DELIMITER |
| + localDependencyName; |
| } |
| flattenDependency(flattenedList, fullDependencyName); |
| if (!flattenedList.contains(fullDependencyName)) { |
| flattenedList.add(fullDependencyName); |
| } |
| } |
| } |
| |
| /** |
| * get the list of dependent targets which must be evaluated for the |
| * given target. |
| * |
| * @param fullTargetName the full name (in reference space) of the |
| * target |
| * @return the flattened list of targets |
| * @exception ExecutionException if the given target could not be found |
| */ |
| protected List getTargetDependencies(String fullTargetName) |
| throws ExecutionException { |
| List flattenedList = new ArrayList(); |
| flattenDependency(flattenedList, fullTargetName); |
| flattenedList.add(fullTargetName); |
| return flattenedList; |
| } |
| |
| |
| /** |
| * Execute the tasks of a target in this frame with the given name |
| * |
| * @param targetName the name of the target whose tasks will be evaluated |
| * @exception ExecutionException if there is a problem executing the tasks |
| * of the target |
| */ |
| protected void executeTarget(String targetName) throws ExecutionException { |
| |
| // to execute a target we must determine its dependencies and |
| // execute them in order. |
| |
| // firstly build a list of fully qualified target names to execute. |
| List dependencyOrder = getTargetDependencies(targetName); |
| |
| for (Iterator i = dependencyOrder.iterator(); i.hasNext();) { |
| String fullTargetName = (String) i.next(); |
| Frame frame = getContainingFrame(fullTargetName); |
| String localTargetName = getNameInFrame(fullTargetName); |
| |
| frame.executeTargetTasks(localTargetName); |
| } |
| } |
| |
| |
| /** |
| * Run the tasks returned by the given iterator |
| * |
| * @param taskIterator the iterator giving the tasks to execute |
| * @exception ExecutionException if there is execution problem while |
| * executing tasks |
| */ |
| protected void executeTasks(Iterator taskIterator) |
| throws ExecutionException { |
| while (taskIterator.hasNext()) { |
| BuildElement model = (BuildElement) taskIterator.next(); |
| |
| // what sort of element is this. |
| try { |
| Object component = componentManager.createComponent(model); |
| |
| if (component instanceof Task) { |
| execService.executeTask((Task) component); |
| } else { |
| String typeId |
| = model.getAspectValue(Constants.ANT_ASPECT, "id"); |
| |
| if (typeId != null) { |
| setDataValue(typeId, component, true); |
| } |
| } |
| } catch (ExecutionException e) { |
| e.setLocation(model.getLocation(), false); |
| throw e; |
| } catch (RuntimeException e) { |
| ExecutionException ee = |
| new ExecutionException(e, model.getLocation()); |
| |
| throw ee; |
| } |
| } |
| |
| } |
| |
| |
| /** |
| * Execute the given target's tasks. The target must be local to this |
| * frame's project |
| * |
| * @param targetName the name of the target within this frame that is to |
| * be executed. |
| * @exception ExecutionException if there is a problem executing tasks |
| */ |
| protected void executeTargetTasks(String targetName) |
| throws ExecutionException { |
| Throwable failureCause = null; |
| Target target = project.getTarget(targetName); |
| String ifCondition = target.getIfCondition(); |
| String unlessCondition = target.getUnlessCondition(); |
| |
| if (ifCondition != null) { |
| ifCondition = dataService.replacePropertyRefs(ifCondition.trim()); |
| if (!isDataValueSet(ifCondition)) { |
| return; |
| } |
| } |
| |
| if (unlessCondition != null) { |
| unlessCondition |
| = dataService.replacePropertyRefs(unlessCondition.trim()); |
| if (isDataValueSet(unlessCondition)) { |
| return; |
| } |
| } |
| |
| try { |
| Iterator taskIterator = target.getTasks(); |
| |
| eventSupport.fireTargetStarted(target); |
| executeTasks(taskIterator); |
| } catch (ExecutionException e) { |
| e.setLocation(target.getLocation(), false); |
| failureCause = e; |
| throw e; |
| } catch (RuntimeException e) { |
| ExecutionException ee = |
| new ExecutionException(e, target.getLocation()); |
| |
| failureCause = ee; |
| throw ee; |
| } finally { |
| eventSupport.fireTargetFinished(target, failureCause); |
| } |
| } |
| |
| |
| /** |
| * Initialize the frame by executing the project level tasks if any |
| * |
| * @exception ExecutionException if the top level tasks of the frame |
| * failed |
| */ |
| protected void initialize() throws ExecutionException { |
| configureServices(); |
| setMagicProperties(); |
| determineBaseDir(); |
| |
| try { |
| // load system ant lib |
| URL systemLibs |
| = new URL(initConfig.getLibraryURL(), "syslibs/"); |
| componentManager.loadLib(systemLibs.toString(), true, true); |
| |
| // execute any config tasks |
| executeTasks(config.getTasks()); |
| |
| // now load other system libraries |
| URL antLibs = new URL(initConfig.getLibraryURL(), "antlibs/"); |
| componentManager.loadLib(antLibs.toString(), false, true); |
| |
| executeTasks(project.getTasks()); |
| } catch (MalformedURLException e) { |
| throw new ExecutionException("Unable to initialize antlibs", e); |
| } |
| } |
| |
| |
| /** |
| * Determine the base directory for each frame in the frame hierarchy |
| * |
| * @exception ExecutionException if the base directories cannot be |
| * determined |
| */ |
| private void determineBaseDir() throws ExecutionException { |
| if (isDataValueSet(MagicProperties.BASEDIR)) { |
| baseDir |
| = new File(getDataValue(MagicProperties.BASEDIR).toString()); |
| } else { |
| URL projectURL = project.getSourceURL(); |
| |
| if (projectURL.getProtocol().equals("file")) { |
| File projectFile = new File(projectURL.getFile()); |
| File projectFileParent = projectFile.getParentFile(); |
| String base = project.getBase(); |
| |
| if (base == null) { |
| baseDir = projectFileParent; |
| } else { |
| FileUtils fileUtils = FileUtils.newFileUtils(); |
| |
| baseDir = fileUtils.resolveFile(projectFileParent, base); |
| } |
| } else { |
| baseDir = new File("."); |
| } |
| } |
| setDataValue(MagicProperties.BASEDIR, baseDir.getAbsolutePath(), true); |
| } |
| |
| |
| /** |
| * Configure the services that the frame makes available to its library |
| * components |
| */ |
| private void configureServices() { |
| // create services and make them available in our services map |
| fileService = new CoreFileService(this); |
| componentManager = new ComponentManager(this); |
| dataService = new CoreDataService(this, |
| config.isUnsetPropertiesAllowed()); |
| execService = new CoreExecService(this); |
| |
| services.put(FileService.class, fileService); |
| services.put(ComponentService.class, componentManager); |
| services.put(DataService.class, dataService); |
| services.put(EventService.class, new CoreEventService(this)); |
| services.put(ExecService.class, execService); |
| services.put(InputService.class, new CoreInputService(this)); |
| } |
| |
| |
| /** |
| * Handle the content from a single thread. This method will be called by |
| * the thread producing the content. The content is broken up into |
| * separate lines |
| * |
| * @param line the content produce by the current thread. |
| * @param isErr true if this content is from the thread's error stream. |
| */ |
| public void threadOutput(String line, boolean isErr) { |
| eventSupport.threadOutput(line, isErr); |
| } |
| } |
| |
| |
