|
|
|
@@ -1,920 +0,0 @@ |
|
|
|
/* |
|
|
|
* The Apache Software License, Version 1.1 |
|
|
|
* |
|
|
|
* Copyright (c) 2001 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.core.execution; |
|
|
|
|
|
|
|
import org.apache.ant.core.model.*; |
|
|
|
import org.apache.ant.core.support.*; |
|
|
|
import org.apache.ant.core.types.*; |
|
|
|
|
|
|
|
import java.util.*; |
|
|
|
import java.net.*; |
|
|
|
|
|
|
|
/** |
|
|
|
* An ExecutionFrame is the state of a project during an execution. |
|
|
|
* The ExecutionFrame contains the data values set by Ant tasks as |
|
|
|
* they are executed, including task definitions, property values, etc. |
|
|
|
* |
|
|
|
* @author <a href="mailto:conor@apache.org">Conor MacNeill</a> |
|
|
|
*/ |
|
|
|
public class ExecutionFrame { |
|
|
|
/** State used in dependency analysis when a target's dependencies are being |
|
|
|
examined. */ |
|
|
|
private static final String VISITING = "VISITING"; |
|
|
|
|
|
|
|
/** State used in dependency analysis to indicate a target has been examined */ |
|
|
|
private static final String VISITED = "VISITED"; |
|
|
|
|
|
|
|
/** The Project that this execiton frame is processing */ |
|
|
|
private Project project = null; |
|
|
|
|
|
|
|
/** The base URL for this frame. This is derived from the |
|
|
|
Project's source URL and it's base attribute. */ |
|
|
|
private URL baseURL = null; |
|
|
|
|
|
|
|
/** The imported frames of this frame. For each project imported by this frame's |
|
|
|
project, a corresponding ExecutionFrame is created. */ |
|
|
|
private Map importedFrames = new HashMap(); |
|
|
|
|
|
|
|
/** BuildEvent support used to fire events and manage listeners */ |
|
|
|
private BuildEventSupport eventSupport = new BuildEventSupport(); |
|
|
|
|
|
|
|
/** The context of this execution. This contains all data object's |
|
|
|
created by tasks that have been executed */ |
|
|
|
private Map dataValues = new HashMap(); |
|
|
|
|
|
|
|
/** Introspector objects used to configure Tasks from the Task models.*/ |
|
|
|
private Map introspectors = new HashMap(); |
|
|
|
|
|
|
|
/** The task defs that this frame will use to process tasks */ |
|
|
|
private Map taskDefs = new HashMap(); |
|
|
|
|
|
|
|
/** Type converters for this executionFrame. Converters are used when configuring |
|
|
|
Tasks to handle special type conversions. */ |
|
|
|
private Map converters = new HashMap(); |
|
|
|
|
|
|
|
/** The aspect handler active in this frame */ |
|
|
|
private Map aspectHandlers = new HashMap(); |
|
|
|
|
|
|
|
/** The namespace under which this execution frame lives in the hierarchical |
|
|
|
project namespace - null for the root namespace */ |
|
|
|
private String namespace; |
|
|
|
|
|
|
|
/** |
|
|
|
* Construct an execution frame to process the given project model with |
|
|
|
* the configuration represented by the libraries. |
|
|
|
* |
|
|
|
* @param project the model of the project to be built. |
|
|
|
* @param libraries an Array of AntLibrary objects containing the |
|
|
|
* configuration of Ant for this build. |
|
|
|
* |
|
|
|
* @throws ConfigException when the project cannot be setup with the |
|
|
|
* given configuration |
|
|
|
*/ |
|
|
|
public ExecutionFrame(Project project, AntLibrary[] libraries) |
|
|
|
throws ConfigException { |
|
|
|
|
|
|
|
this.namespace = null; |
|
|
|
setupFrame(project, libraries); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Construct a subframe for managing a project imported into the main project. |
|
|
|
* @param project the model of the project to be built. |
|
|
|
* @param libraries an Array of AntLibrary objects containing the |
|
|
|
* configuration of Ant for this build. |
|
|
|
* @param namespace the location of this project within the overall import |
|
|
|
* namespace. |
|
|
|
* |
|
|
|
* @throws ConfigException when the project cannot be setup with the |
|
|
|
* given configuration |
|
|
|
*/ |
|
|
|
private ExecutionFrame(Project project, AntLibrary[] libraries, String namespace) |
|
|
|
throws ConfigException { |
|
|
|
|
|
|
|
this.namespace = namespace; |
|
|
|
setupFrame(project, libraries); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
* Set up the execution frame. |
|
|
|
* |
|
|
|
* This method examines the project model and constructs the required |
|
|
|
* subframes to handle imported projects. |
|
|
|
* @param project the model of the project to be built. |
|
|
|
* @param libraries an Array of AntLibrary objects containing the |
|
|
|
* configuration of Ant for this build. |
|
|
|
* |
|
|
|
* @throws ConfigException when the project cannot be setup with the |
|
|
|
* given configuration |
|
|
|
*/ |
|
|
|
private void setupFrame(Project project, AntLibrary[] libraries) |
|
|
|
throws ConfigException { |
|
|
|
|
|
|
|
this.project = project; |
|
|
|
for (int i = 0; i < libraries.length; ++i) { |
|
|
|
addLibrary(libraries[i]); |
|
|
|
} |
|
|
|
|
|
|
|
try { |
|
|
|
String base = project.getBase(); |
|
|
|
if (base == null) { |
|
|
|
baseURL = project.getSourceURL(); |
|
|
|
} |
|
|
|
else { |
|
|
|
base = base.trim(); |
|
|
|
if (!base.endsWith("/")) { |
|
|
|
base += "/"; |
|
|
|
} |
|
|
|
baseURL = new URL(project.getSourceURL(), base); |
|
|
|
} |
|
|
|
} |
|
|
|
catch (MalformedURLException e) { |
|
|
|
throw new ConfigException("Project's base value \"" + project.getBase() |
|
|
|
+ "\" is not valid", e, project.getLocation()); |
|
|
|
} |
|
|
|
|
|
|
|
for (Iterator i = project.getImportedProjectNames(); i.hasNext();) { |
|
|
|
String importName = (String)i.next(); |
|
|
|
Project importedProject = project.getImportedProject(importName); |
|
|
|
String importNamespace |
|
|
|
= namespace == null ? importName : namespace + ":" + importName; |
|
|
|
ExecutionFrame importedFrame |
|
|
|
= new ExecutionFrame(importedProject, libraries, importNamespace); |
|
|
|
importedFrames.put(importName, importedFrame); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Add a configuration library to this execution frame. The library |
|
|
|
* will contain task definitions, converters, apsect handler definitions, |
|
|
|
* etc. |
|
|
|
* |
|
|
|
* @param library the configuration library to add to this frame. |
|
|
|
* |
|
|
|
* @throws ConfigException if the items in the library cannot be configured. |
|
|
|
*/ |
|
|
|
public void addLibrary(AntLibrary library) throws ConfigException { |
|
|
|
for (Iterator i = library.getTaskDefinitions(); i.hasNext(); ) { |
|
|
|
TaskDefinition taskDefinition = (TaskDefinition)i.next(); |
|
|
|
addTaskDefinition(taskDefinition); |
|
|
|
} |
|
|
|
for (Iterator i = library.getConverterDefinitions(); i.hasNext(); ) { |
|
|
|
ConverterDefinition converterDef = (ConverterDefinition)i.next(); |
|
|
|
addConverterDefinition(converterDef); |
|
|
|
} |
|
|
|
for (Iterator i = library.getAspectDefinitions(); i.hasNext(); ) { |
|
|
|
AspectDefinition aspectDef = (AspectDefinition)i.next(); |
|
|
|
addAspectHandler(aspectDef); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Add a task definition to this execution frame |
|
|
|
* |
|
|
|
* @param taskDefinition the TaskDefinition to be added to the project. |
|
|
|
*/ |
|
|
|
public void addTaskDefinition(TaskDefinition taskDefinition) { |
|
|
|
String taskName = taskDefinition.getName(); |
|
|
|
taskDefs.put(taskName, taskDefinition); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Add a aspect handler definition to this execution frame |
|
|
|
* |
|
|
|
* @param taskDefinition the TaskDefinition to be added to the project. |
|
|
|
* |
|
|
|
* @throws ConfigException if the aspect handler cannot be created or configured. |
|
|
|
*/ |
|
|
|
public void addAspectHandler(AspectDefinition aspectDefinition) |
|
|
|
throws ConfigException { |
|
|
|
String aspectPrefix = aspectDefinition.getAspectPrefix(); |
|
|
|
try { |
|
|
|
Class aspectHandlerClass = aspectDefinition.getAspectHandlerClass(); |
|
|
|
aspectHandlers.put(aspectPrefix, aspectHandlerClass); |
|
|
|
} |
|
|
|
catch (ClassNotFoundException e) { |
|
|
|
throw new ConfigException("Unable to load aspect handler class for " |
|
|
|
+ aspectDefinition.getAspectHandlerClassName() |
|
|
|
+ " in converter from " + aspectDefinition.getLibraryURL(), |
|
|
|
e); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Add a converter definition to this library. |
|
|
|
* |
|
|
|
* The converter is created immediately to handle conversions |
|
|
|
* when items are being configured. If the converter is an instance of |
|
|
|
* an AntConverter, the converter is configured with this execution |
|
|
|
* frame giving it the context it needs to resolve items relative to the |
|
|
|
* project's base, etc. |
|
|
|
* |
|
|
|
* @param converterDef the converter definition to load |
|
|
|
* |
|
|
|
* @throws ConfigException if the converter cannot be created or configured. |
|
|
|
*/ |
|
|
|
public void addConverterDefinition(ConverterDefinition converterDef) throws ConfigException { |
|
|
|
boolean targetLoaded = false; |
|
|
|
try { |
|
|
|
Class targetClass = converterDef.getTargetClass(); |
|
|
|
targetLoaded = false; |
|
|
|
Class converterClass = converterDef.getConverterClass(); |
|
|
|
Converter converter = (AntConverter)converterClass.newInstance(); |
|
|
|
if (converter instanceof AntConverter) { |
|
|
|
((AntConverter)converter).init(this); |
|
|
|
} |
|
|
|
converters.put(targetClass, converter); |
|
|
|
} |
|
|
|
catch (ClassNotFoundException e) { |
|
|
|
if (targetLoaded) { |
|
|
|
throw new ConfigException("Unable to load converter class for " |
|
|
|
+ converterDef.getConverterClassName() |
|
|
|
+ " in converter from " + converterDef.getLibraryURL(), |
|
|
|
e); |
|
|
|
} |
|
|
|
else { |
|
|
|
throw new ConfigException("Unable to load target class " |
|
|
|
+ converterDef.getTargetClassName() |
|
|
|
+ " in converter from " + converterDef.getLibraryURL(), |
|
|
|
e); |
|
|
|
} |
|
|
|
} |
|
|
|
catch (InstantiationException e) { |
|
|
|
throw new ConfigException("Unable to instantiate converter class " |
|
|
|
+ converterDef.getTargetClassName() |
|
|
|
+ " in converter from " + converterDef.getLibraryURL(), |
|
|
|
e); |
|
|
|
} |
|
|
|
catch (IllegalAccessException e) { |
|
|
|
throw new ConfigException("Unable to access converter class " |
|
|
|
+ converterDef.getTargetClassName() |
|
|
|
+ " in converter from " + converterDef.getLibraryURL(), |
|
|
|
e); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
* Get the bae URL of this frame. This will either be specified by the project's |
|
|
|
* base attribute or be derived implicitly from the project's location. |
|
|
|
*/ |
|
|
|
public URL getBaseURL() { |
|
|
|
return baseURL; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
public void addBuildListener(BuildListener listener) { |
|
|
|
for (Iterator i = getImportedFrames(); i.hasNext(); ) { |
|
|
|
ExecutionFrame subFrame = (ExecutionFrame)i.next(); |
|
|
|
subFrame.addBuildListener(listener); |
|
|
|
} |
|
|
|
eventSupport.addBuildListener(listener); |
|
|
|
} |
|
|
|
|
|
|
|
public void removeBuildListener(BuildListener listener) { |
|
|
|
for (Iterator i = getImportedFrames(); i.hasNext(); ) { |
|
|
|
ExecutionFrame subFrame = (ExecutionFrame)i.next(); |
|
|
|
subFrame.removeBuildListener(listener); |
|
|
|
} |
|
|
|
eventSupport.removeBuildListener(listener); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get the project associated with this execution frame. |
|
|
|
* |
|
|
|
* @return the project associated iwth this execution frame. |
|
|
|
*/ |
|
|
|
public Project getProject() { |
|
|
|
return project; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
* Get the names of the frames representing imported projects. |
|
|
|
* |
|
|
|
* @return an iterator which returns the names of the imported frames. |
|
|
|
*/ |
|
|
|
public Iterator getImportedFrameNames() { |
|
|
|
return importedFrames.keySet().iterator(); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
* Get the frames representing imported projects. |
|
|
|
* |
|
|
|
* @return an iterator which returns the imported ExeuctionFrames.. |
|
|
|
*/ |
|
|
|
public Iterator getImportedFrames() { |
|
|
|
return importedFrames.values().iterator(); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get an imported frame by name |
|
|
|
* |
|
|
|
* @param importName the name under which the frame was imported. |
|
|
|
* |
|
|
|
* @return the ExecutionFrame asscociated with the given import name or null |
|
|
|
* if there is no such project. |
|
|
|
*/ |
|
|
|
public ExecutionFrame getImportedFrame(String importName) { |
|
|
|
return (ExecutionFrame)importedFrames.get(importName); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get the location of this frame in the namespace hierarchy |
|
|
|
* |
|
|
|
* @return the location of this frame within the project import |
|
|
|
* namespace hierarchy. |
|
|
|
*/ |
|
|
|
public String getNamespace() { |
|
|
|
return namespace; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get the fully qualified name of something with respect to this |
|
|
|
* execution frame. |
|
|
|
* |
|
|
|
* @param name the unqualified name. |
|
|
|
* |
|
|
|
* @return the fully qualified version of the given name |
|
|
|
*/ |
|
|
|
public String getQualifiedName(String name) { |
|
|
|
return namespace == null ? name : namespace + ":" + name; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Execute the given target's tasks |
|
|
|
* |
|
|
|
* @param the name of the target within this frame that is to be executed. |
|
|
|
*/ |
|
|
|
public void executeTargetTasks(String targetName) throws ExecutionException, ConfigException { |
|
|
|
Target target = project.getTarget(targetName); |
|
|
|
try { |
|
|
|
Iterator taskIterator = target.getTasks(); |
|
|
|
eventSupport.fireTargetStarted(this, target); |
|
|
|
executeTasks(taskIterator); |
|
|
|
eventSupport.fireTargetFinished(this, target, null); |
|
|
|
} |
|
|
|
catch (RuntimeException e) { |
|
|
|
eventSupport.fireTargetFinished(this, target, e); |
|
|
|
throw e; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Initialize the frame by executing the project level tasks if any |
|
|
|
*/ |
|
|
|
public void initialize() throws ExecutionException, ConfigException { |
|
|
|
for (Iterator i = getImportedFrames(); i.hasNext(); ) { |
|
|
|
ExecutionFrame subFrame = (ExecutionFrame)i.next(); |
|
|
|
subFrame.initialize(); |
|
|
|
} |
|
|
|
Iterator taskIterator = project.getTasks(); |
|
|
|
executeTasks(taskIterator); |
|
|
|
} |
|
|
|
|
|
|
|
public void fillinDependencyOrder(String targetName, List dependencyOrder, |
|
|
|
Map state, Stack visiting) throws ConfigException { |
|
|
|
String fullTargetName = getQualifiedName(targetName); |
|
|
|
if (state.get(fullTargetName) == VISITED) { |
|
|
|
return; |
|
|
|
} |
|
|
|
Target target = getProject().getTarget(targetName); |
|
|
|
if (target == null) { |
|
|
|
StringBuffer sb = new StringBuffer("Target `"); |
|
|
|
sb.append(targetName); |
|
|
|
sb.append("' does not exist in this project. "); |
|
|
|
if (!visiting.empty()) { |
|
|
|
String parent = (String)visiting.peek(); |
|
|
|
sb.append("It is used from target `"); |
|
|
|
sb.append(parent); |
|
|
|
sb.append("'."); |
|
|
|
} |
|
|
|
|
|
|
|
throw new ConfigException(new String(sb), getProject().getLocation()); |
|
|
|
} |
|
|
|
|
|
|
|
state.put(fullTargetName, VISITING); |
|
|
|
visiting.push(fullTargetName); |
|
|
|
for (Iterator i = target.getDependencies(); i.hasNext(); ) { |
|
|
|
String dependency = (String)i.next(); |
|
|
|
try { |
|
|
|
ExecutionFrame dependencyFrame = getRelativeFrame(dependency); |
|
|
|
if (dependencyFrame == null) { |
|
|
|
StringBuffer sb = new StringBuffer("Target `"); |
|
|
|
sb.append(dependency); |
|
|
|
sb.append("' does not exist in this project. "); |
|
|
|
throw new ConfigException(new String(sb), target.getLocation()); |
|
|
|
} |
|
|
|
|
|
|
|
String fullyQualifiedName = getQualifiedName(dependency); |
|
|
|
String dependencyState = (String)state.get(fullyQualifiedName); |
|
|
|
if (dependencyState == null) { |
|
|
|
dependencyFrame.fillinDependencyOrder(getNameInFrame(dependency), dependencyOrder, |
|
|
|
state, visiting); |
|
|
|
} |
|
|
|
else if (dependencyState == VISITING) { |
|
|
|
String circleDescription |
|
|
|
= getCircularDesc(dependency, visiting); |
|
|
|
throw new ConfigException(circleDescription, target.getLocation()); |
|
|
|
} |
|
|
|
} |
|
|
|
catch (ExecutionException e) { |
|
|
|
throw new ConfigException(e.getMessage(), e, target.getLocation()); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
state.put(fullTargetName, VISITED); |
|
|
|
String poppedNode = (String)visiting.pop(); |
|
|
|
if (poppedNode != fullTargetName) { |
|
|
|
throw new ConfigException("Problem determining dependencies " + |
|
|
|
" - expecting '" + fullTargetName + |
|
|
|
"' but got '" + poppedNode + "'"); |
|
|
|
} |
|
|
|
dependencyOrder.add(fullTargetName); |
|
|
|
} |
|
|
|
|
|
|
|
private String getCircularDesc(String end, Stack visitingNodes) { |
|
|
|
StringBuffer sb = new StringBuffer("Circular dependency: "); |
|
|
|
sb.append(end); |
|
|
|
String c; |
|
|
|
do { |
|
|
|
c = (String)visitingNodes.pop(); |
|
|
|
sb.append(" <- "); |
|
|
|
sb.append(c); |
|
|
|
} while(!c.equals(end)); |
|
|
|
return new String(sb); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Check whether the targets in this frame and its subframes are OK |
|
|
|
*/ |
|
|
|
public void checkTargets(List dependencyOrder, Map state, Stack visiting) |
|
|
|
throws ConfigException { |
|
|
|
// get the targets and just iterate through them. |
|
|
|
for (Iterator i = getProject().getTargets(); i.hasNext();) { |
|
|
|
Target target = (Target)i.next(); |
|
|
|
fillinDependencyOrder(target.getName(), |
|
|
|
dependencyOrder, state, visiting); |
|
|
|
} |
|
|
|
|
|
|
|
// Now do the subframes. |
|
|
|
for (Iterator i = getImportedFrames(); i.hasNext();) { |
|
|
|
ExecutionFrame importedFrame = (ExecutionFrame)i.next(); |
|
|
|
importedFrame.checkTargets(dependencyOrder, state, visiting); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
* Create a Task and configure it according to the given model. |
|
|
|
*/ |
|
|
|
private Task configureTask(TaskElement model) |
|
|
|
throws ConfigException, ExecutionException { |
|
|
|
|
|
|
|
String taskType = model.getType(); |
|
|
|
TaskDefinition taskDefinition = (TaskDefinition)taskDefs.get(taskType); |
|
|
|
if (taskDefinition == null) { |
|
|
|
throw new ConfigException("There is no defintion for tasks of type <" |
|
|
|
+ taskType + ">", model.getLocation()); |
|
|
|
} |
|
|
|
|
|
|
|
try { |
|
|
|
Class elementClass = taskDefinition.getExecutionTaskClass(); |
|
|
|
Object element = elementClass.newInstance(); |
|
|
|
Task task = null; |
|
|
|
if (element instanceof Task) { |
|
|
|
// create a Task context for the Task |
|
|
|
task = (Task)element; |
|
|
|
} |
|
|
|
else { |
|
|
|
task = new TaskAdapter(taskType, element); |
|
|
|
} |
|
|
|
|
|
|
|
configureElement(element, model); |
|
|
|
|
|
|
|
return task; |
|
|
|
} |
|
|
|
catch (ClassNotFoundException e) { |
|
|
|
throw new ConfigException("Execution class " + taskDefinition.getTaskClassName() |
|
|
|
+ " was not found", e, model.getLocation()); |
|
|
|
} |
|
|
|
catch (InstantiationException e) { |
|
|
|
throw new ConfigException("Unable to instantiate execution class " |
|
|
|
+ taskDefinition.getTaskClassName(), |
|
|
|
e, model.getLocation()); |
|
|
|
} |
|
|
|
catch (IllegalAccessException e) { |
|
|
|
throw new ConfigException("Unable to access execution class " |
|
|
|
+ taskDefinition.getTaskClassName(), |
|
|
|
e, model.getLocation()); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
private List getActiveAspects(BuildElement model) |
|
|
|
throws ConfigException, ExecutionException, |
|
|
|
ClassIntrospectionException, ConversionException { |
|
|
|
List activeAspects = new ArrayList(); |
|
|
|
for (Iterator i = model.getAspectNames(); i.hasNext();) { |
|
|
|
String aspectPrefix = (String)i.next(); |
|
|
|
Class aspectHandlerClass = (Class)aspectHandlers.get(aspectPrefix); |
|
|
|
if (aspectHandlerClass != null) { |
|
|
|
try { |
|
|
|
AspectHandler aspectHandler |
|
|
|
= (AspectHandler)aspectHandlerClass.newInstance(); |
|
|
|
ClassIntrospector introspector = getIntrospector(aspectHandlerClass); |
|
|
|
|
|
|
|
ExecutionContext context = new ExecutionContext(this, eventSupport, model); |
|
|
|
aspectHandler.setAspectContext(context); |
|
|
|
|
|
|
|
Map aspectAttributes = model.getAspectAttributes(aspectPrefix); |
|
|
|
for (Iterator j = aspectAttributes.keySet().iterator(); j.hasNext();) { |
|
|
|
String attributeName = (String)j.next(); |
|
|
|
String attributeValue = (String)aspectAttributes.get(attributeName); |
|
|
|
introspector.setAttribute(aspectHandler, attributeName, |
|
|
|
replacePropertyRefs(attributeValue)); |
|
|
|
} |
|
|
|
activeAspects.add(aspectHandler); |
|
|
|
} |
|
|
|
catch (InstantiationException e) { |
|
|
|
throw new ConfigException("Unable to instantiate aspect handler class " |
|
|
|
+ aspectHandlerClass, |
|
|
|
e); |
|
|
|
} |
|
|
|
catch (IllegalAccessException e) { |
|
|
|
throw new ConfigException("Unable to access aspect handler class " |
|
|
|
+ aspectHandlerClass, |
|
|
|
e); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
|
|
|
return activeAspects; |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
* Configure an element according to the given model. |
|
|
|
*/ |
|
|
|
private void configureElement(Object element, TaskElement model) |
|
|
|
throws ExecutionException, ConfigException { |
|
|
|
|
|
|
|
if (element instanceof Task) { |
|
|
|
Task task = (Task)element; |
|
|
|
ExecutionContext context = new ExecutionContext(this, eventSupport, model); |
|
|
|
task.setTaskContext(context); |
|
|
|
} |
|
|
|
try { |
|
|
|
ClassIntrospector introspector = getIntrospector(element.getClass()); |
|
|
|
|
|
|
|
List aspects = getActiveAspects(model); |
|
|
|
for (Iterator i = aspects.iterator(); i.hasNext(); ) { |
|
|
|
AspectHandler aspectHandler = (AspectHandler)i.next(); |
|
|
|
aspectHandler.beforeConfigElement(element); |
|
|
|
} |
|
|
|
|
|
|
|
// start by setting the attributes of this element |
|
|
|
for (Iterator i = model.getAttributeNames(); i.hasNext();) { |
|
|
|
String attributeName = (String)i.next(); |
|
|
|
String attributeValue = model.getAttributeValue(attributeName); |
|
|
|
introspector.setAttribute(element, attributeName, |
|
|
|
replacePropertyRefs(attributeValue)); |
|
|
|
} |
|
|
|
|
|
|
|
String modelText = model.getText().trim(); |
|
|
|
if (modelText.length() != 0) { |
|
|
|
introspector.addText(element, replacePropertyRefs(modelText)); |
|
|
|
} |
|
|
|
|
|
|
|
// now do the nested elements |
|
|
|
for (Iterator i = model.getNestedElements(); i.hasNext();) { |
|
|
|
TaskElement nestedElementModel = (TaskElement)i.next(); |
|
|
|
if (element instanceof TaskContainer && |
|
|
|
!introspector.supportsNestedElement(nestedElementModel.getType())) { |
|
|
|
|
|
|
|
Task nestedTask = configureTask(nestedElementModel); |
|
|
|
TaskContainer container = (TaskContainer)element; |
|
|
|
container.addTask(nestedTask); |
|
|
|
} |
|
|
|
else { |
|
|
|
Object nestedElement |
|
|
|
= introspector.createElement(element, nestedElementModel.getType()); |
|
|
|
configureElement(nestedElement, nestedElementModel); |
|
|
|
} |
|
|
|
} |
|
|
|
for (Iterator i = aspects.iterator(); i.hasNext(); ) { |
|
|
|
AspectHandler aspectHandler = (AspectHandler)i.next(); |
|
|
|
aspectHandler.afterConfigElement(element); |
|
|
|
} |
|
|
|
} |
|
|
|
catch (ClassIntrospectionException e) { |
|
|
|
throw new ExecutionException(e, model.getLocation()); |
|
|
|
} |
|
|
|
catch (ConversionException e) { |
|
|
|
throw new ExecutionException(e, model.getLocation()); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Run the tasks returned by the give iterator |
|
|
|
* |
|
|
|
* @param taskIterator the iterator giving the tasks to execute |
|
|
|
*/ |
|
|
|
public void executeTasks(Iterator taskIterator) throws ExecutionException, ConfigException { |
|
|
|
TaskElement task = null; |
|
|
|
try { |
|
|
|
while (taskIterator.hasNext()) { |
|
|
|
task = (TaskElement)taskIterator.next(); |
|
|
|
try { |
|
|
|
Task configuredTask = configureTask(task); |
|
|
|
eventSupport.fireTaskStarted(this, task); |
|
|
|
configuredTask.execute(); |
|
|
|
} |
|
|
|
catch (ExecutionException e) { |
|
|
|
if (e.getLocation() == null || e.getLocation() == Location.UNKNOWN_LOCATION) { |
|
|
|
e.setLocation(task.getLocation()); |
|
|
|
} |
|
|
|
throw e; |
|
|
|
} |
|
|
|
catch (ConfigException e) { |
|
|
|
if (e.getLocation() == null || e.getLocation() == Location.UNKNOWN_LOCATION) { |
|
|
|
e.setLocation(task.getLocation()); |
|
|
|
} |
|
|
|
throw e; |
|
|
|
} |
|
|
|
eventSupport.fireTaskFinished(this, task, null); |
|
|
|
} |
|
|
|
} |
|
|
|
catch (RuntimeException e) { |
|
|
|
eventSupport.fireTaskFinished(this, task, e); |
|
|
|
throw e; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
private ClassIntrospector getIntrospector(Class c) { |
|
|
|
if (introspectors.containsKey(c)) { |
|
|
|
return (ClassIntrospector)introspectors.get(c); |
|
|
|
} |
|
|
|
ClassIntrospector introspector = new ClassIntrospector(c, converters); |
|
|
|
introspectors.put(c, introspector); |
|
|
|
return introspector; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Replace ${} style constructions in the given value with the string value of |
|
|
|
* the corresponding data types. |
|
|
|
* |
|
|
|
* @param value the string to be scanned for property references. |
|
|
|
*/ |
|
|
|
public String replacePropertyRefs(String value) throws ExecutionException { |
|
|
|
if (value == null) { |
|
|
|
return null; |
|
|
|
} |
|
|
|
|
|
|
|
List fragments = new ArrayList(); |
|
|
|
List propertyRefs = new ArrayList(); |
|
|
|
parsePropertyString(value, fragments, propertyRefs); |
|
|
|
|
|
|
|
StringBuffer sb = new StringBuffer(); |
|
|
|
Iterator i = fragments.iterator(); |
|
|
|
Iterator j = propertyRefs.iterator(); |
|
|
|
while (i.hasNext()) { |
|
|
|
String fragment = (String)i.next(); |
|
|
|
if (fragment == null) { |
|
|
|
String propertyName = (String)j.next(); |
|
|
|
if (!isDataValueSet(propertyName)) { |
|
|
|
throw new ExecutionException("Property " + propertyName + " has not been set"); |
|
|
|
} |
|
|
|
fragment = getDataValue(propertyName).toString(); |
|
|
|
} |
|
|
|
sb.append(fragment); |
|
|
|
} |
|
|
|
|
|
|
|
return sb.toString(); |
|
|
|
} |
|
|
|
|
|
|
|
|
|
|
|
/** |
|
|
|
* This method will parse a string containing ${value} style |
|
|
|
* property values into two list. The first list is a collection |
|
|
|
* of text fragments, while the other is a set of string property names |
|
|
|
* null entries in the first list indicate a property reference from the |
|
|
|
* second list. |
|
|
|
*/ |
|
|
|
static public void parsePropertyString(String value, List fragments, List propertyRefs) |
|
|
|
throws ExecutionException { |
|
|
|
int prev = 0; |
|
|
|
int pos; |
|
|
|
while ((pos = value.indexOf("$", prev)) >= 0) { |
|
|
|
if (pos > 0) { |
|
|
|
fragments.add(value.substring(prev, pos)); |
|
|
|
} |
|
|
|
|
|
|
|
if( pos == (value.length() - 1)) { |
|
|
|
fragments.add("$"); |
|
|
|
prev = pos + 1; |
|
|
|
} |
|
|
|
else if (value.charAt(pos + 1) != '{' ) { |
|
|
|
fragments.add(value.substring(pos + 1, pos + 2)); |
|
|
|
prev = pos + 2; |
|
|
|
} else { |
|
|
|
int endName = value.indexOf('}', pos); |
|
|
|
if (endName < 0) { |
|
|
|
throw new ExecutionException("Syntax error in property: " |
|
|
|
+ value ); |
|
|
|
} |
|
|
|
String propertyName = value.substring(pos + 2, endName); |
|
|
|
fragments.add(null); |
|
|
|
propertyRefs.add(propertyName); |
|
|
|
prev = endName + 1; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
if (prev < value.length()) { |
|
|
|
fragments.add(value.substring(prev)); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Given a name of an object, get the frame relative from this frame that |
|
|
|
* contains that object. |
|
|
|
*/ |
|
|
|
public ExecutionFrame getRelativeFrame(String name) throws ExecutionException { |
|
|
|
int index = name.lastIndexOf(":"); |
|
|
|
if (index == -1) { |
|
|
|
return this; |
|
|
|
} |
|
|
|
|
|
|
|
ExecutionFrame currentFrame = this; |
|
|
|
String relativeFrameName = name.substring(0, index); |
|
|
|
StringTokenizer tokenizer = new StringTokenizer(relativeFrameName, ":"); |
|
|
|
while (tokenizer.hasMoreTokens()) { |
|
|
|
String frameName = tokenizer.nextToken(); |
|
|
|
currentFrame = currentFrame.getImportedFrame(frameName); |
|
|
|
if (currentFrame == null) { |
|
|
|
throw new ExecutionException("The project " + frameName + " in " |
|
|
|
+ name + " was not found"); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
return currentFrame; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get the name of an object in its frame |
|
|
|
*/ |
|
|
|
public String getNameInFrame(String name) { |
|
|
|
int index = name.lastIndexOf(":"); |
|
|
|
if (index == -1) { |
|
|
|
return name; |
|
|
|
} |
|
|
|
return name.substring(index+1); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Set a value in this frame or any of its imported frames |
|
|
|
*/ |
|
|
|
public void setDataValue(String name, Object value) throws ExecutionException { |
|
|
|
ExecutionFrame frame = getRelativeFrame(name); |
|
|
|
frame.setDirectDataValue(getNameInFrame(name), value); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get a value from this frame or any imported frame |
|
|
|
*/ |
|
|
|
public Object getDataValue(String name) throws ExecutionException { |
|
|
|
ExecutionFrame frame = getRelativeFrame(name); |
|
|
|
return frame.getDirectDataValue(getNameInFrame(name)); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Set a value in this frame only |
|
|
|
*/ |
|
|
|
private void setDirectDataValue(String name, Object value) { |
|
|
|
dataValues.put(name, value); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Get a value from this frame |
|
|
|
*/ |
|
|
|
private Object getDirectDataValue(String name) { |
|
|
|
return dataValues.get(name); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Indicate if a data value has been set |
|
|
|
*/ |
|
|
|
public boolean isDataValueSet(String name) throws ExecutionException { |
|
|
|
ExecutionFrame frame = getRelativeFrame(name); |
|
|
|
return frame.isDirectDataValueSet(getNameInFrame(name)); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Indicate if a data value has been set in this frame |
|
|
|
*/ |
|
|
|
private boolean isDirectDataValueSet(String name) { |
|
|
|
return dataValues.containsKey(name); |
|
|
|
} |
|
|
|
|
|
|
|
public void runBuild(List targetNames) throws AntException { |
|
|
|
Throwable buildFailureCause = null; |
|
|
|
try { |
|
|
|
eventSupport.fireBuildStarted(this, project); |
|
|
|
initialize(); |
|
|
|
|
|
|
|
if (targetNames.isEmpty()) { |
|
|
|
// we just execute the default target if any |
|
|
|
String defaultTarget = project.getDefaultTarget(); |
|
|
|
if (defaultTarget != null) { |
|
|
|
executeTarget(defaultTarget); |
|
|
|
} |
|
|
|
} |
|
|
|
else { |
|
|
|
for (Iterator i = targetNames.iterator(); i.hasNext();) { |
|
|
|
executeTarget((String)i.next()); |
|
|
|
} |
|
|
|
} |
|
|
|
eventSupport.fireBuildFinished(this, project, null); |
|
|
|
} |
|
|
|
catch (RuntimeException e) { |
|
|
|
buildFailureCause = e; |
|
|
|
throw e; |
|
|
|
} |
|
|
|
catch (AntException e) { |
|
|
|
buildFailureCause = e; |
|
|
|
throw e; |
|
|
|
} |
|
|
|
finally { |
|
|
|
eventSupport.fireBuildFinished(this, project, buildFailureCause); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
public void executeTarget(String targetName) throws ExecutionException, ConfigException { |
|
|
|
// to execute a target we must determine its dependencies and |
|
|
|
// execute them in order. |
|
|
|
Map state = new HashMap(); |
|
|
|
Stack visiting = new Stack(); |
|
|
|
List dependencyOrder = new ArrayList(); |
|
|
|
ExecutionFrame startingFrame = getRelativeFrame(targetName); |
|
|
|
startingFrame.fillinDependencyOrder(getNameInFrame(targetName), |
|
|
|
dependencyOrder, state, visiting); |
|
|
|
|
|
|
|
// Now tell each frame to execute the targets required |
|
|
|
for (Iterator i = dependencyOrder.iterator(); i.hasNext();) { |
|
|
|
String fullTargetName = (String)i.next(); |
|
|
|
ExecutionFrame frame = getRelativeFrame(fullTargetName); |
|
|
|
frame.executeTargetTasks(getNameInFrame(fullTargetName)); |
|
|
|
} |
|
|
|
} |
|
|
|
} |
Conor MacNeill