|
|
|
@@ -1,397 +0,0 @@ |
|
|
|
/* |
|
|
|
* The Apache Software License, Version 1.1 |
|
|
|
* |
|
|
|
* Copyright (c) 1999, 2000 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", "Tomcat", 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.engine; |
|
|
|
|
|
|
|
|
|
|
|
import java.util.*; |
|
|
|
import org.apache.ant.AntException; |
|
|
|
import org.apache.ant.tasks.Task; |
|
|
|
|
|
|
|
/** |
|
|
|
* The engine that actually invokes each Task. In addition to specifying a Task |
|
|
|
* to execute, it may be desirable to specify the root Task that will define |
|
|
|
* an execution cycle. |
|
|
|
*/ |
|
|
|
public class TaskEngineImpl implements TaskEngine { |
|
|
|
|
|
|
|
/** |
|
|
|
* Analagous to a call stack, but with Tasks. |
|
|
|
*/ |
|
|
|
protected Stack taskStack = new Stack();; |
|
|
|
|
|
|
|
/** |
|
|
|
* As the task stack is built, a mirror representation will also be |
|
|
|
* contructed that will hold property values. |
|
|
|
*/ |
|
|
|
protected Stack propertyStack = new Stack(); |
|
|
|
|
|
|
|
/** |
|
|
|
* Keeps track of AntEngineListeners. We don't have to use Vector because we |
|
|
|
* take care of synchronization on the add, remove, and iteration operations. |
|
|
|
*/ |
|
|
|
protected ArrayList listenerList = new ArrayList(); |
|
|
|
|
|
|
|
private int engineLevel = 0; |
|
|
|
|
|
|
|
/** |
|
|
|
* Constructor is private so it cannot be instantiated. Users of this class |
|
|
|
* will get an instance by using the getTaskEngine() method. This will allow |
|
|
|
* us to have a simple Factory implementation. We may use a Singleton |
|
|
|
* implementation, or a collection pool. The choice is up to us. |
|
|
|
*/ |
|
|
|
private TaskEngineImpl() { |
|
|
|
super(); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Return a usable instance of a TaskEngine to the requestor. Nothing |
|
|
|
* sophisticated yet, simple doles out a new instance each time. |
|
|
|
*/ |
|
|
|
public static TaskEngine getTaskEngine() { |
|
|
|
return new TaskEngineImpl(); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Walk the list of Tasks backwards until the root is reached. Keep track of |
|
|
|
* the Tasks along the way in a Stack. Return null if the root Task is not a |
|
|
|
* parent of the provided Task. |
|
|
|
*/ |
|
|
|
protected Stack getTaskStack(Task root, Task task) { |
|
|
|
Stack stack = new Stack(); |
|
|
|
while (task != null) { |
|
|
|
stack.push(task); |
|
|
|
if (task == root) { |
|
|
|
return stack; |
|
|
|
} |
|
|
|
task = task.getParent(); |
|
|
|
} |
|
|
|
return null; |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Returns the next Task to be executed from the taskStack. The task is not |
|
|
|
* removed from the Stack. |
|
|
|
*/ |
|
|
|
public Task getNextExecuteTask() { |
|
|
|
try { |
|
|
|
return (Task)taskStack.peek(); |
|
|
|
} catch (EmptyStackException esx) { |
|
|
|
return null; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* If no root is specified, we will assume that the user wants to execute |
|
|
|
* the Task with no root. This is accomplished by using the Task parameter |
|
|
|
* as its own root. |
|
|
|
*/ |
|
|
|
public void execute(Task task) throws AntException { |
|
|
|
execute(task, task); |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* This is the workhorse, however it has been made to be very simple. Given |
|
|
|
* the ability to specify a path between root and the target Task, we build |
|
|
|
* a trail of Tasks to connect the two. Next we execute each Task on the way |
|
|
|
* between the two Tasks. Once we arrive at the Task to execute, we execute |
|
|
|
* all of its chlidren. |
|
|
|
*/ |
|
|
|
public void execute(Task root, Task task) throws AntException { |
|
|
|
fireEngineStart(); |
|
|
|
try { |
|
|
|
taskStack = getTaskStack(root, task);; |
|
|
|
if (taskStack == null) { |
|
|
|
throw new AntException( |
|
|
|
"The execution root Task is not an ancestor of the execution Task."); |
|
|
|
} |
|
|
|
|
|
|
|
// Pop thru the stack and execute each Task we come across. |
|
|
|
while (!taskStack.isEmpty()) { |
|
|
|
executeTask(taskStack); |
|
|
|
} |
|
|
|
} finally { |
|
|
|
fireEngineFinish(); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* A recursive routine that allows all Tasks in the stack to be executed. At |
|
|
|
* the same time, the stack may grow to include new Tasks. |
|
|
|
*/ |
|
|
|
protected void executeTask(Stack taskStack) throws AntException { |
|
|
|
Task task = (Task)taskStack.pop(); |
|
|
|
|
|
|
|
fireTaskStart(task); |
|
|
|
try { |
|
|
|
// Add a new property holder for this task to the property stack. Note |
|
|
|
// that the parent of the new holder is the current stack head. |
|
|
|
if (task.isPropertyContainer()) { |
|
|
|
if (propertyStack.isEmpty()) { |
|
|
|
propertyStack.push(new HierarchicalHashtable()); |
|
|
|
} else { |
|
|
|
propertyStack.push(new HierarchicalHashtable( |
|
|
|
(HierarchicalHashtable)propertyStack.peek())); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
// Allow Task to do whatever it may need to do before touching its |
|
|
|
// children. |
|
|
|
task.init(this); |
|
|
|
|
|
|
|
// Iterate the Task's children and execute any priority Tasks. |
|
|
|
Task[] tasks = task.getChildren(); |
|
|
|
for (int i = 0, c = tasks.length; i < c; i++) { |
|
|
|
if (tasks[i].getExecutionMode() == Task.EXECUTION_MODE_PRIORITY) { |
|
|
|
taskStack.push(tasks[i]); |
|
|
|
executeTask(taskStack); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
// Allow the Task to validate. |
|
|
|
task.validate(); |
|
|
|
|
|
|
|
// Finally, execute the Task. |
|
|
|
fireTaskExecute(task); |
|
|
|
task.execute(this); |
|
|
|
|
|
|
|
// We can discard the no londer needed property holder. |
|
|
|
if (task.isPropertyContainer()) { |
|
|
|
propertyStack.pop(); |
|
|
|
} |
|
|
|
|
|
|
|
} catch (AntException ax) { |
|
|
|
fireTaskException(task, ax); |
|
|
|
} finally { |
|
|
|
fireTaskFinish(task); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
/** |
|
|
|
* Causes an AntEvent to be generated and fired to all listeners. |
|
|
|
*/ |
|
|
|
public void message(Task task, String message) { |
|
|
|
fireTaskMessage(task, message); |
|
|
|
} |
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
|
|
// Listener Support // |
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
|
|
public synchronized void addAntEngineListener(AntEngineListener listener) { |
|
|
|
if (!listenerList.contains(listener)) { |
|
|
|
listenerList.add(listener); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
public synchronized void removeAntEngineListener(AntEngineListener listener) { |
|
|
|
if (listenerList.contains(listener)) { |
|
|
|
listenerList.remove(listener); |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
protected synchronized void fireEngineStart() { |
|
|
|
if (engineLevel++ > 0) return; |
|
|
|
AntEvent e = new AntEvent(this); |
|
|
|
for (int i = 0; i < listenerList.size(); i++) { |
|
|
|
((AntEngineListener)listenerList.get(i)).engineStart(e); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
protected synchronized void fireEngineFinish() { |
|
|
|
if (--engineLevel > 0) return; |
|
|
|
AntEvent e = new AntEvent(this); |
|
|
|
for (int i = 0; i < listenerList.size(); i++) { |
|
|
|
((AntEngineListener)listenerList.get(i)).engineFinish(e); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
protected synchronized void fireTaskStart(Task task) { |
|
|
|
AntEvent e = new AntEvent(this, task); |
|
|
|
for (int i = 0; i < listenerList.size(); i++) { |
|
|
|
((AntEngineListener)listenerList.get(i)).taskStart(e); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
protected synchronized void fireTaskExecute(Task task) { |
|
|
|
AntEvent e = new AntEvent(this, task); |
|
|
|
for (int i = 0; i < listenerList.size(); i++) { |
|
|
|
((AntEngineListener)listenerList.get(i)).taskExecute(e); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
protected synchronized void fireTaskFinish(Task task) { |
|
|
|
AntEvent e = new AntEvent(this, task); |
|
|
|
for (int i = 0; i < listenerList.size(); i++) { |
|
|
|
((AntEngineListener)listenerList.get(i)).taskFinish(e); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
protected synchronized void fireTaskMessage(Task task, String message) { |
|
|
|
AntEvent e = new AntEvent(this, task); |
|
|
|
for (int i = 0; i < listenerList.size(); i++) { |
|
|
|
((AntEngineListener)listenerList.get(i)).taskMessage(e, message); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
protected synchronized void fireTaskException(Task task, AntException exception) { |
|
|
|
AntEvent e = new AntEvent(this, task); |
|
|
|
for (int i = 0; i < listenerList.size(); i++) { |
|
|
|
((AntEngineListener)listenerList.get(i)).taskException(e, exception); |
|
|
|
} |
|
|
|
|
|
|
|
} |
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
|
|
// Property Support Methods // |
|
|
|
//////////////////////////////////////////////////////////////////////////// |
|
|
|
|
|
|
|
/** |
|
|
|
* This is the routine that will perform key substitution. Phrase will come |
|
|
|
* in as "src/${someparam}" and be converted to the appropriate "normalized" |
|
|
|
* string. I suppose while I'm doing this we should support phrases with |
|
|
|
* nested keys, such as "src/${build${token}}". Also, we should properly |
|
|
|
* handle cases where ${someparam} will evaluate to ${anotherparam}. |
|
|
|
* <p></p> |
|
|
|
* One thing that will be different from the Ant 1.2 mechanismoccurs when a |
|
|
|
* parameter value is not found. The substitution routine inserts it back in |
|
|
|
* the phrase unchanged. I have opted to insert a zero-length string |
|
|
|
* instead. |
|
|
|
* <p></p> |
|
|
|
* I should add a switch to the engine that will give the user the ability |
|
|
|
* to throw an exception if a key is not found. Pretty easy, except this |
|
|
|
* method is a strange place for an AntException to be thrown. Perhaps I |
|
|
|
* should use a RuntimeException instead... |
|
|
|
* <p></p> |
|
|
|
* A brief rundown on the logic here: |
|
|
|
* I check for the first instances of a key prefix. |
|
|
|
* If none found we return the phrase as is. |
|
|
|
* If key prefix is found get location of next key prefix and suffix. |
|
|
|
* If suffix is found first, we have found a key. |
|
|
|
* If there is no suffix, we return the phrase. |
|
|
|
*/ |
|
|
|
static final String KEY_PREFIX = "${"; |
|
|
|
static final String KEY_SUFFIX = "}"; |
|
|
|
protected String substitute(String phrase) { |
|
|
|
StringBuffer sb = new StringBuffer(phrase); |
|
|
|
int startPoint = 0; |
|
|
|
while (startPoint >= 0 && startPoint < phrase.length()) { |
|
|
|
int pre1 = startPoint + phrase.substring(startPoint).indexOf(KEY_PREFIX); |
|
|
|
if (pre1 < 0) break; |
|
|
|
int suf1 = phrase.substring(pre1 + KEY_PREFIX.length()).indexOf(KEY_SUFFIX); |
|
|
|
if (suf1 < 0) break; |
|
|
|
suf1 = suf1 + pre1 + KEY_PREFIX.length(); |
|
|
|
int pre2 = phrase.substring(pre1 + KEY_PREFIX.length()).indexOf(KEY_PREFIX); |
|
|
|
if (pre2 < 0) { |
|
|
|
pre2 = phrase.length() + 1; |
|
|
|
} else { |
|
|
|
pre2 = pre2 + pre1 + KEY_PREFIX.length(); |
|
|
|
} |
|
|
|
|
|
|
|
if (suf1 < pre2) { |
|
|
|
// we have found a token |
|
|
|
String key = sb.substring(pre1 + KEY_PREFIX.length(), suf1); |
|
|
|
sb.delete(pre1, suf1 + 1); |
|
|
|
Object value = getPropertyValueNoSubstitution(key); |
|
|
|
if (value != null) { |
|
|
|
sb.insert(pre1, value.toString()); |
|
|
|
} |
|
|
|
return substitute(sb.toString()); |
|
|
|
} |
|
|
|
startPoint = pre2; |
|
|
|
} |
|
|
|
return sb.toString(); |
|
|
|
} |
|
|
|
|
|
|
|
public List getPropertyNames() { |
|
|
|
if (propertyStack.isEmpty()) return new ArrayList(); |
|
|
|
HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek(); |
|
|
|
return hash.getPropertyNames(); |
|
|
|
} |
|
|
|
|
|
|
|
public Object getPropertyValue(String name) { |
|
|
|
if (propertyStack.isEmpty()) return null; |
|
|
|
HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek(); |
|
|
|
Object result = hash.getPropertyValue(name); |
|
|
|
if (result instanceof String) { |
|
|
|
return substitute((String)result); |
|
|
|
} else { |
|
|
|
return result; |
|
|
|
} |
|
|
|
} |
|
|
|
|
|
|
|
protected Object getPropertyValueNoSubstitution(String name) { |
|
|
|
if (propertyStack.isEmpty()) return null; |
|
|
|
HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek(); |
|
|
|
return hash.getPropertyValue(name); |
|
|
|
} |
|
|
|
|
|
|
|
public void setPropertyValue(String name, Object value) { |
|
|
|
if (propertyStack.isEmpty()) return; |
|
|
|
HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek(); |
|
|
|
hash.setPropertyValue(name, value); |
|
|
|
} |
|
|
|
|
|
|
|
public void removePropertyValue(String name) { |
|
|
|
if (propertyStack.isEmpty()) return; |
|
|
|
HierarchicalHashtable hash = (HierarchicalHashtable)propertyStack.peek(); |
|
|
|
hash.remove(name); |
|
|
|
} |
|
|
|
} |
Peter Donald