* <target name="foo" depends="init">
* <ant antfile="build.xml" target="bar" >
* <property name="property1" value="aaaaa" />
* <property name="foo" value="baz" />
* </ant>
* </target>
*
* <target name="bar" depends="init">
* <echo message="prop is ${property1} ${foo}" />
* </target>
*
*
*
* @since Ant 1.1
*
* @ant.task category="control"
*/
public class Ant extends Task {
/** the basedir where is executed the build file */
private File dir = null;
/**
* the build.xml file (can be absolute) in this case dir will be
* ignored
*/
private String antFile = null;
/** the output */
private String output = null;
/** should we inherit properties from the parent ? */
private boolean inheritAll = true;
/** should we inherit references from the parent ? */
private boolean inheritRefs = false;
/** the properties to pass to the new project */
private Vector properties = new Vector();
/** the references to pass to the new project */
private Vector references = new Vector();
/** the temporary project created to run the build file */
private Project newProject;
/** The stream to which output is to be written. */
private PrintStream out = null;
/** the sets of properties to pass to the new project */
private Vector propertySets = new Vector();
/** the targets to call on the new project */
private Vector targets = new Vector();
/** whether the target attribute was specified **/
private boolean targetAttributeSet = false;
/**
* If true, pass all properties to the new Ant project.
* Defaults to true.
* @param value if true pass all properties to the new Ant project.
*/
public void setInheritAll(boolean value) {
inheritAll = value;
}
/**
* If true, pass all references to the new Ant project.
* Defaults to false.
* @param value if true, pass all references to the new Ant project
*/
public void setInheritRefs(boolean value) {
inheritRefs = value;
}
/**
* Creates a Project instance for the project to call.
*/
public void init() {
newProject = new Project();
newProject.setDefaultInputStream(getProject().getDefaultInputStream());
newProject.setJavaVersionProperty();
}
/**
* Called in execute or createProperty if newProject is null.
*
* This can happen if the same instance of this task is run * twice as newProject is set to null at the end of execute (to * save memory and help the GC).
*calls init() again
* */ private void reinit() { init(); } /** * Attaches the build listeners of the current project to the new * project, configures a possible logfile, transfers task and * data-type definitions, transfers properties (either all or just * the ones specified as user properties to the current project, * depending on inheritall), transfers the input handler. */ private void initializeProject() { newProject.setInputHandler(getProject().getInputHandler()); Iterator iter = getBuildListeners(); while (iter.hasNext()) { newProject.addBuildListener((BuildListener) iter.next()); } if (output != null) { File outfile = null; if (dir != null) { outfile = FileUtils.newFileUtils().resolveFile(dir, output); } else { outfile = getProject().resolveFile(output); } try { out = new PrintStream(new FileOutputStream(outfile)); DefaultLogger logger = new DefaultLogger(); logger.setMessageOutputLevel(Project.MSG_INFO); logger.setOutputPrintStream(out); logger.setErrorPrintStream(out); newProject.addBuildListener(logger); } catch (IOException ex) { log("Ant: Can't set output to " + output); } } getProject().initSubProject(newProject); // set user-defined properties getProject().copyUserProperties(newProject); if (!inheritAll) { // set Java built-in properties separately, // b/c we won't inherit them. newProject.setSystemProperties(); } else { // set all properties from calling project addAlmostAll(getProject().getProperties()); } Enumeration e = propertySets.elements(); while (e.hasMoreElements()) { PropertySet ps = (PropertySet) e.nextElement(); addAlmostAll(ps.getProperties()); } } /** * Pass output sent to System.out to the new project. * * @param output a line of output * @since Ant 1.5 */ public void handleOutput(String output) { if (newProject != null) { newProject.demuxOutput(output, false); } else { super.handleOutput(output); } } /** * Process input into the ant task * * @param buffer the buffer into which data is to be read. * @param offset the offset into the buffer at which data is stored. * @param length the amount of data to read * * @return the number of bytes read * * @exception IOException if the data cannot be read * * @see Task#handleInput(byte[], int, int) * * @since Ant 1.6 */ public int handleInput(byte[] buffer, int offset, int length) throws IOException { if (newProject != null) { return newProject.demuxInput(buffer, offset, length); } else { return super.handleInput(buffer, offset, length); } } /** * Pass output sent to System.out to the new project. * * @param output The output to log. Should not benull.
*
* @since Ant 1.5.2
*/
public void handleFlush(String output) {
if (newProject != null) {
newProject.demuxFlush(output, false);
} else {
super.handleFlush(output);
}
}
/**
* Pass output sent to System.err to the new project.
*
* @param output The error output to log. Should not be null.
*
* @since Ant 1.5
*/
public void handleErrorOutput(String output) {
if (newProject != null) {
newProject.demuxOutput(output, true);
} else {
super.handleErrorOutput(output);
}
}
/**
* Pass output sent to System.err to the new project.
*
* @param output The error output to log. Should not be null.
*
* @since Ant 1.5.2
*/
public void handleErrorFlush(String output) {
if (newProject != null) {
newProject.demuxFlush(output, true);
} else {
super.handleErrorFlush(output);
}
}
/**
* Do the execution.
* @throws BuildException if a target tries to call itself
* probably also if a BuildException is thrown by the new project
*/
public void execute() throws BuildException {
File savedDir = dir;
String savedAntFile = antFile;
Vector locals = new Vector(targets);
try {
if (newProject == null) {
reinit();
}
if ((dir == null) && (inheritAll)) {
dir = getProject().getBaseDir();
}
initializeProject();
if (dir != null) {
newProject.setBaseDir(dir);
if (savedDir != null) {
// has been set explicitly
newProject.setInheritedProperty("basedir" ,
dir.getAbsolutePath());
}
} else {
dir = getProject().getBaseDir();
}
overrideProperties();
if (antFile == null) {
antFile = "build.xml";
}
File file = FileUtils.newFileUtils().resolveFile(dir, antFile);
antFile = file.getAbsolutePath();
log("calling target(s) "
+ ((locals.size() == 0) ? locals.toString() : "[default]")
+ " in build file " + antFile, Project.MSG_VERBOSE);
newProject.setUserProperty("ant.file" , antFile);
String thisAntFile = getProject().getProperty("ant.file");
// Are we trying to call the target in which we are defined (or
// the build file if this is a top level task)?
if (thisAntFile != null
&& newProject.resolveFile(newProject.getProperty("ant.file"))
.equals(getProject().resolveFile(thisAntFile))
&& getOwningTarget() != null) {
if (getOwningTarget().getName().equals("")) {
if (getTaskName().equals("antcall")) {
throw new BuildException("antcall must not be used at"
+ " the top level.");
} else {
throw new BuildException(getTaskName() + " task at the"
+ " top level must not invoke"
+ " its own build file.");
}
}
}
try {
ProjectHelper.configureProject(newProject, new File(antFile));
} catch (BuildException ex) {
throw ProjectHelper.addLocationToBuildException(
ex, getLocation());
}
if (locals.size() == 0) {
String defaultTarget = newProject.getDefaultTarget();
if (defaultTarget != null) {
locals.add(defaultTarget);
}
}
if (newProject.getProperty("ant.file")
.equals(getProject().getProperty("ant.file"))
&& getOwningTarget() != null) {
String owningTargetName = getOwningTarget().getName();
if (locals.contains(owningTargetName)) {
throw new BuildException(getTaskName() + " task calling "
+ "its own parent target.");
} else {
boolean circular = false;
for (Iterator it = locals.iterator(); !circular && it.hasNext();) {
Target other = (Target)(getProject().getTargets().get(
(String)(it.next())));
circular |= (other != null
&& other.dependsOn(owningTargetName));
}
if (circular) {
throw new BuildException(getTaskName()
+ " task calling a target"
+ " that depends on"
+ " its parent target \'"
+ owningTargetName
+ "\'.");
}
}
}
addReferences();
if (locals.size() > 0 && !(locals.size() == 1 && locals.get(0) == "")) {
Throwable t = null;
try {
log("Entering " + antFile + "...", Project.MSG_VERBOSE);
newProject.fireSubBuildStarted();
String[] nameArray =
(String[])(locals.toArray(new String[locals.size()]));
Hashtable targets = newProject.getTargets();
Vector sortedTargets = newProject.topoSort(nameArray, targets);
sortedTargets.setSize(sortedTargets.indexOf(targets.get(
locals.lastElement())) + 1);
newProject.executeSortedTargets(sortedTargets);
} catch (BuildException ex) {
t = ProjectHelper
.addLocationToBuildException(ex, getLocation());
throw (BuildException) t;
} finally {
log("Exiting " + antFile + ".", Project.MSG_VERBOSE);
newProject.fireSubBuildFinished(t);
}
}
} finally {
// help the gc
newProject = null;
Enumeration e = properties.elements();
while (e.hasMoreElements()) {
Property p = (Property) e.nextElement();
p.setProject(null);
}
if (output != null && out != null) {
try {
out.close();
} catch (final Exception ex) {
//ignore
}
}
dir = savedDir;
antFile = savedAntFile;
}
}
/**
* Override the properties in the new project with the one
* explicitly defined as nested elements here.
* @throws BuildException under unknown circumstances
*/
private void overrideProperties() throws BuildException {
// remove duplicate properties - last property wins
// Needed for backward compatibility
Set set = new HashSet();
for (int i = properties.size() - 1; i >= 0; --i) {
Property p = (Property) properties.get(i);
if (p.getName() != null && !p.getName().equals("")) {
if (set.contains(p.getName())) {
properties.remove(i);
} else {
set.add(p.getName());
}
}
}
Enumeration e = properties.elements();
while (e.hasMoreElements()) {
Property p = (Property) e.nextElement();
p.setProject(newProject);
p.execute();
}
getProject().copyInheritedProperties(newProject);
}
/**
* Add the references explicitly defined as nested elements to the
* new project. Also copy over all references that don't override
* existing references in the new project if inheritrefs has been
* requested.
* @throws BuildException if a reference does not have a refid
*/
private void addReferences() throws BuildException {
Hashtable thisReferences
= (Hashtable) getProject().getReferences().clone();
Hashtable newReferences = newProject.getReferences();
Enumeration e;
if (references.size() > 0) {
for (e = references.elements(); e.hasMoreElements();) {
Reference ref = (Reference) e.nextElement();
String refid = ref.getRefId();
if (refid == null) {
throw new BuildException("the refid attribute is required"
+ " for reference elements");
}
if (!thisReferences.containsKey(refid)) {
log("Parent project doesn't contain any reference '"
+ refid + "'",
Project.MSG_WARN);
continue;
}
thisReferences.remove(refid);
String toRefid = ref.getToRefid();
if (toRefid == null) {
toRefid = refid;
}
copyReference(refid, toRefid);
}
}
// Now add all references that are not defined in the
// subproject, if inheritRefs is true
if (inheritRefs) {
for (e = thisReferences.keys(); e.hasMoreElements();) {
String key = (String) e.nextElement();
if (newReferences.containsKey(key)) {
continue;
}
copyReference(key, key);
}
}
}
/**
* Try to clone and reconfigure the object referenced by oldkey in
* the parent project and add it to the new project with the key
* newkey.
*
* If we cannot clone it, copy the referenced object itself and * keep our fingers crossed.
*/ private void copyReference(String oldKey, String newKey) { Object orig = getProject().getReference(oldKey); if (orig == null) { log("No object referenced by " + oldKey + ". Can't copy to " + newKey, Project.MSG_WARN); return; } Class c = orig.getClass(); Object copy = orig; try { Method cloneM = c.getMethod("clone", new Class[0]); if (cloneM != null) { copy = cloneM.invoke(orig, new Object[0]); log("Adding clone of reference " + oldKey, Project.MSG_DEBUG); } } catch (Exception e) { // not Clonable } if (copy instanceof ProjectComponent) { ((ProjectComponent) copy).setProject(newProject); } else { try { Method setProjectM = c.getMethod("setProject", new Class[] {Project.class}); if (setProjectM != null) { setProjectM.invoke(copy, new Object[] {newProject}); } } catch (NoSuchMethodException e) { // ignore this if the class being referenced does not have // a set project method. } catch (Exception e2) { String msg = "Error setting new project instance for " + "reference with id " + oldKey; throw new BuildException(msg, e2, getLocation()); } } newProject.addReference(newKey, copy); } /** * Copies all properties from the given table to the new project - * omitting those that have already been set in the new project as * well as properties named basedir or ant.file. * @param props properties to copy to the new project * @since Ant 1.6 */ private void addAlmostAll(Hashtable props) { Enumeration e = props.keys(); while (e.hasMoreElements()) { String key = e.nextElement().toString(); if ("basedir".equals(key) || "ant.file".equals(key)) { // basedir and ant.file get special treatment in execute() continue; } String value = props.get(key).toString(); // don't re-set user properties, avoid the warning message if (newProject.getProperty(key) == null) { // no user property newProject.setNewProperty(key, value); } } } /** * The directory to use as a base directory for the new Ant project. * Defaults to the current project's basedir, unless inheritall * has been set to false, in which case it doesn't have a default * value. This will override the basedir setting of the called project. * @param d new directory */ public void setDir(File d) { this.dir = d; } /** * The build file to use. * Defaults to "build.xml". This file is expected to be a filename relative * to the dir attribute given. * @param s build file to use */ public void setAntfile(String s) { // @note: it is a string and not a file to handle relative/absolute // otherwise a relative file will be resolved based on the current // basedir. this.antFile = s; } /** * The target of the new Ant project to execute. * Defaults to the new project's default target. * @param s target to invoke */ public void setTarget(String s) { if (s.equals("")) { throw new BuildException("target attribute must not be empty"); } targets.add(s); targetAttributeSet = true; } /** * Filename to write the output to. * This is relative to the value of the dir attribute * if it has been set or to the base directory of the * current project otherwise. * @param s file to which the output should go to */ public void setOutput(String s) { this.output = s; } /** * Property to pass to the new project. * The property is passed as a 'user property' * @return new property created */ public Property createProperty() { if (newProject == null) { reinit(); } Property p = new Property(true, getProject()); p.setProject(newProject); p.setTaskName("property"); properties.addElement(p); return p; } /** * Reference element identifying a data type to carry * over to the new project. * @param r reference to add */ public void addReference(Reference r) { references.addElement(r); } /** * Add a target to this Ant invocation. * @param target theTargetElement to add.
* @since Ant 1.7
*/
public void addConfiguredTarget(TargetElement t) {
if (targetAttributeSet) {
throw new BuildException(
"nested target is incompatible with the target attribute");
}
String name = t.getName();
if (name.equals("")) {
throw new BuildException("target name must not be empty");
}
targets.add(name);
}
/**
* Set of properties to pass to the new project.
*
* @param ps property set to add
* @since Ant 1.6
*/
public void addPropertyset(PropertySet ps) {
propertySets.addElement(ps);
}
/**
* @since Ant 1.6.2
*/
private Iterator getBuildListeners() {
return getProject().getBuildListeners().iterator();
}
/**
* Helper class that implements the nested <reference>
* element of <ant> and <antcall>.
*/
public static class Reference
extends org.apache.tools.ant.types.Reference {
/** Creates a reference to be configured by Ant */
public Reference() {
super();
}
private String targetid = null;
/**
* Set the id that this reference to be stored under in the
* new project.
*
* @param targetid the id under which this reference will be passed to
* the new project */
public void setToRefid(String targetid) {
this.targetid = targetid;
}
/**
* Get the id under which this reference will be stored in the new
* project
*
* @return the id of the reference in the new project.
*/
public String getToRefid() {
return targetid;
}
}
/**
* Helper class that implements the nested <target>
* element of <ant> and <antcall>.
* @since Ant 1.7
*/
public static class TargetElement {
private String name;
/**
* Default constructor.
*/
public TargetElement() {}
/**
* Set the name of this TargetElement.
* @param name the String target name.
*/
public void setName(String name) {
this.name = name;
}
/**
* Get the name of this TargetElement.
* @return String.
*/
public String getName() {
return name;
}
}
}