* Added ExecuteJava.setIgnoreReturnCode() and executeForked() methods. * Converted the remaining tasks from CommandlineJava to ExecuteJava. * Removed CommandlineJava. * Added convenience methods to Commandline and EnvironmentData. * Made SysProperties into a static util class. It now longer extends EnvironmentData, and can now handle Map (and Properties) as well as EnvironmentData. git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@271918 13f79535-47bb-0310-9956-ffa450edef68master
| @@ -509,7 +509,7 @@ Legal: | |||
| </target> | |||
| <!-- Compiles and runs the unit tests --> | |||
| <target name="run-tests" depends="dist-lite" if="junit.present" description="Runs the unit tests"> | |||
| <target name="run-tests" depends="dist-lite" if="junit.present"> | |||
| <!-- Compile the unit tests --> | |||
| <mkdir dir="${test.classes}"/> | |||
| <javac srcdir="src/testcases" | |||
| @@ -13,10 +13,7 @@ import java.io.FileReader; | |||
| import java.net.URL; | |||
| import org.apache.myrmidon.api.AbstractTask; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.types.Argument; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.types.Path; | |||
| /** | |||
| @@ -25,88 +22,63 @@ import org.apache.tools.todo.types.Path; | |||
| * @author <a href="mailto:emeade@geekfarm.org">Erik Meade</a> | |||
| * @author <a href="mailto:sbailliez@apache.org>Stephane Bailliez</a> | |||
| */ | |||
| public class ANTLR extends AbstractTask | |||
| public class ANTLR | |||
| extends AbstractTask | |||
| { | |||
| private CommandlineJava commandline = new CommandlineJava(); | |||
| /** | |||
| * should fork ? | |||
| */ | |||
| private boolean fork = false; | |||
| /** | |||
| * working directory | |||
| */ | |||
| private File workingdir = null; | |||
| private final ExecuteJava m_exe = new ExecuteJava(); | |||
| /** | |||
| * where to output the result | |||
| */ | |||
| private File outputDirectory; | |||
| private File m_outputDirectory; | |||
| /** | |||
| * the file to process | |||
| */ | |||
| private File target; | |||
| public ANTLR() | |||
| { | |||
| commandline.setVm( "java" ); | |||
| commandline.setClassname( "antlr.Tool" ); | |||
| } | |||
| private File m_target; | |||
| /** | |||
| * The working directory of the process | |||
| * | |||
| * @param d The new Dir value | |||
| * @param dir The new Dir value | |||
| */ | |||
| public void setDir( File d ) | |||
| public void setDir( final File dir ) | |||
| { | |||
| this.workingdir = d; | |||
| m_exe.setWorkingDirectory( dir ); | |||
| } | |||
| public void setFork( boolean s ) | |||
| public void setFork( final boolean fork ) | |||
| { | |||
| this.fork = s; | |||
| m_exe.setFork( fork ); | |||
| } | |||
| public void setOutputdirectory( File outputDirectory ) | |||
| public void setOutputdirectory( final File outputDirectory ) | |||
| { | |||
| getContext().debug( "Setting output directory to: " + outputDirectory.toString() ); | |||
| this.outputDirectory = outputDirectory; | |||
| m_outputDirectory = outputDirectory; | |||
| } | |||
| public void setTarget( File target ) | |||
| public void setTarget( final File target ) | |||
| { | |||
| getContext().debug( "Setting target to: " + target.toString() ); | |||
| this.target = target; | |||
| m_target = target; | |||
| } | |||
| /** | |||
| * <code><classpath></code> allows classpath to be set because a | |||
| * directory might be given for Antlr debug... | |||
| * | |||
| * @return Description of the Returned Value | |||
| */ | |||
| public Path createClasspath() | |||
| public void addClasspath( final Path path ) | |||
| { | |||
| Path path1 = commandline.createClasspath(); | |||
| final Path path = new Path(); | |||
| path1.addPath( path ); | |||
| return path; | |||
| m_exe.getClassPath().addPath( path ); | |||
| } | |||
| /** | |||
| * Create a new JVM argument. Ignored if no JVM is forked. | |||
| * | |||
| * @return create a new JVM argument so that any argument can be passed to | |||
| * the JVM. | |||
| * @see #setFork(boolean) | |||
| */ | |||
| public void addJvmarg( final Argument argument ) | |||
| { | |||
| commandline.addVmArgument( argument ); | |||
| m_exe.getVmArguments().addArgument( argument ); | |||
| } | |||
| public void execute() | |||
| @@ -119,24 +91,18 @@ public class ANTLR extends AbstractTask | |||
| validateAttributes(); | |||
| //TODO: use ANTLR to parse the grammer file to do this. | |||
| if( target.lastModified() > getGeneratedFile().lastModified() ) | |||
| if( m_target.lastModified() <= getGeneratedFile().lastModified() ) | |||
| { | |||
| commandline.addArgument( "-o" ); | |||
| commandline.addArgument( outputDirectory.toString() ); | |||
| commandline.addArgument( target.toString() ); | |||
| if( fork ) | |||
| { | |||
| run( commandline ); | |||
| } | |||
| else | |||
| { | |||
| ExecuteJava exe = new ExecuteJava(); | |||
| exe.setJavaCommand( commandline.getJavaCommand() ); | |||
| exe.setClasspath( commandline.getClasspath() ); | |||
| exe.execute(); | |||
| } | |||
| return; | |||
| } | |||
| m_exe.setClassName( "antlr.Tool" ); | |||
| m_exe.getArguments().addArgument( "-o" ); | |||
| m_exe.getArguments().addArgument( m_outputDirectory ); | |||
| m_exe.getArguments().addArgument( m_target ); | |||
| m_exe.execute( getContext() ); | |||
| } | |||
| /** | |||
| @@ -148,7 +114,7 @@ public class ANTLR extends AbstractTask | |||
| * | |||
| * @param resource The feature to be added to the ClasspathEntry attribute | |||
| */ | |||
| protected void addClasspathEntry( String resource ) | |||
| protected void addClasspathEntry( final String resource ) | |||
| { | |||
| URL url = getClass().getResource( resource ); | |||
| if( url != null ) | |||
| @@ -159,14 +125,14 @@ public class ANTLR extends AbstractTask | |||
| int pling = u.indexOf( "!" ); | |||
| String jarName = u.substring( 9, pling ); | |||
| getContext().debug( "Implicitly adding " + jarName + " to classpath" ); | |||
| createClasspath().setLocation( new File( ( new File( jarName ) ).getAbsolutePath() ) ); | |||
| m_exe.getClassPath().addLocation( new File( jarName ) ); | |||
| } | |||
| else if( u.startsWith( "file:" ) ) | |||
| { | |||
| int tail = u.indexOf( resource ); | |||
| String dirName = u.substring( 5, tail ); | |||
| getContext().debug( "Implicitly adding " + dirName + " to classpath" ); | |||
| createClasspath().setLocation( new File( ( new File( dirName ) ).getAbsolutePath() ) ); | |||
| m_exe.getClassPath().addLocation( new File( dirName ) ); | |||
| } | |||
| else | |||
| { | |||
| @@ -185,7 +151,7 @@ public class ANTLR extends AbstractTask | |||
| String generatedFileName = null; | |||
| try | |||
| { | |||
| BufferedReader in = new BufferedReader( new FileReader( target ) ); | |||
| BufferedReader in = new BufferedReader( new FileReader( m_target ) ); | |||
| String line; | |||
| while( ( line = in.readLine() ) != null ) | |||
| { | |||
| @@ -206,40 +172,25 @@ public class ANTLR extends AbstractTask | |||
| { | |||
| throw new TaskException( "Unable to determine generated class" ); | |||
| } | |||
| return new File( outputDirectory, generatedFileName + ".java" ); | |||
| } | |||
| /** | |||
| * execute in a forked VM | |||
| * | |||
| * @param command Description of Parameter | |||
| * @exception org.apache.myrmidon.api.TaskException Description of Exception | |||
| */ | |||
| private void run( final Commandline command ) | |||
| throws TaskException | |||
| { | |||
| final Execute exe = new Execute(); | |||
| exe.setWorkingDirectory( workingdir ); | |||
| exe.setCommandline( command ); | |||
| exe.execute( getContext() ); | |||
| return new File( m_outputDirectory, generatedFileName + ".java" ); | |||
| } | |||
| private void validateAttributes() | |||
| throws TaskException | |||
| { | |||
| if( target == null || !target.isFile() ) | |||
| if( m_target == null || !m_target.isFile() ) | |||
| { | |||
| throw new TaskException( "Invalid target: " + target ); | |||
| throw new TaskException( "Invalid target: " + m_target ); | |||
| } | |||
| // if no output directory is specified, used the target's directory | |||
| if( outputDirectory == null ) | |||
| if( m_outputDirectory == null ) | |||
| { | |||
| setOutputdirectory( new File( target.getParent() ) ); | |||
| m_outputDirectory = m_target.getParentFile(); | |||
| } | |||
| if( !outputDirectory.isDirectory() ) | |||
| if( !m_outputDirectory.isDirectory() ) | |||
| { | |||
| throw new TaskException( "Invalid output directory: " + outputDirectory ); | |||
| throw new TaskException( "Invalid output directory: " + m_outputDirectory ); | |||
| } | |||
| } | |||
| } | |||
| @@ -18,6 +18,7 @@ import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.Path; | |||
| import org.apache.tools.todo.types.PathUtil; | |||
| import org.apache.tools.todo.types.EnvironmentData; | |||
| import org.apache.tools.todo.types.SysProperties; | |||
| import org.apache.tools.todo.util.FileUtils; | |||
| import org.apache.aut.nativelib.Os; | |||
| @@ -32,7 +33,7 @@ import org.apache.aut.nativelib.Os; | |||
| public class ExecuteJava | |||
| { | |||
| private final Path m_classPath = new Path(); | |||
| private final SysProperties m_sysProperties = new SysProperties(); | |||
| private final EnvironmentData m_sysProperties = new EnvironmentData(); | |||
| private final Commandline m_args = new Commandline(); | |||
| private final Commandline m_vmArgs = new Commandline(); | |||
| private boolean m_fork; | |||
| @@ -41,6 +42,7 @@ public class ExecuteJava | |||
| private String m_jvm; | |||
| private String m_className; | |||
| private String m_maxMemory; | |||
| private boolean m_ignoreReturnCode; | |||
| public void setClassName( final String className ) | |||
| { | |||
| @@ -57,6 +59,11 @@ public class ExecuteJava | |||
| m_fork = fork; | |||
| } | |||
| /** | |||
| * Sets the max memory to use when running the application in a forked JVM. | |||
| * | |||
| * @param maxMemory the maximum memory, or null for the default. | |||
| */ | |||
| public void setMaxMemory( final String maxMemory ) | |||
| { | |||
| m_maxMemory = maxMemory; | |||
| @@ -67,6 +74,17 @@ public class ExecuteJava | |||
| m_workingDirectory = workingDirectory; | |||
| } | |||
| public void setIgnoreReturnCode( boolean ignore ) | |||
| { | |||
| m_ignoreReturnCode = ignore; | |||
| } | |||
| /** | |||
| * Sets the JVM executable to use to run the application in a forked JVM. | |||
| * | |||
| * @param jvm the path to the JVM executable, or null to use the default | |||
| * JVM executable. | |||
| */ | |||
| public void setJvm( final String jvm ) | |||
| { | |||
| m_jvm = jvm; | |||
| @@ -77,7 +95,7 @@ public class ExecuteJava | |||
| return m_classPath; | |||
| } | |||
| public SysProperties getSysProperties() | |||
| public EnvironmentData getSysProperties() | |||
| { | |||
| return m_sysProperties; | |||
| } | |||
| @@ -92,54 +110,49 @@ public class ExecuteJava | |||
| return m_vmArgs; | |||
| } | |||
| /** | |||
| * Executes the application. | |||
| */ | |||
| public void execute( final TaskContext context ) | |||
| throws TaskException | |||
| { | |||
| // Validate | |||
| if( m_className != null && m_jar != null ) | |||
| { | |||
| throw new TaskException( "Only one of Classname and Jar can be set." ); | |||
| } | |||
| else if( m_className == null && m_jar == null ) | |||
| { | |||
| throw new TaskException( "Classname must not be null." ); | |||
| } | |||
| if( ! m_fork ) | |||
| { | |||
| if( m_jar != null ) | |||
| { | |||
| throw new TaskException( "Cannot execute a jar in non-forked mode." ); | |||
| } | |||
| if( m_vmArgs.size() > 0 ) | |||
| { | |||
| context.warn( "JVM args ignored when same JVM is used." ); | |||
| } | |||
| if( m_workingDirectory != null ) | |||
| { | |||
| context.warn( "Working directory ignored when same JVM is used." ); | |||
| } | |||
| if( m_sysProperties.size() > 0 ) | |||
| { | |||
| context.warn( "System properties ignored when same JVM is used." ); | |||
| } | |||
| } | |||
| if( m_fork ) | |||
| { | |||
| execForked( context ); | |||
| executeForked( context ); | |||
| } | |||
| else | |||
| { | |||
| execNonForked( context ); | |||
| executeNonForked( context ); | |||
| } | |||
| } | |||
| /** | |||
| * Executes the app in this JVM. | |||
| * Executes the application in this JVM. | |||
| */ | |||
| private void execNonForked( final TaskContext context ) | |||
| public void executeNonForked( final TaskContext context ) | |||
| throws TaskException | |||
| { | |||
| if( m_className == null ) | |||
| { | |||
| throw new TaskException( "Classname must not be null." ); | |||
| } | |||
| if( m_jar != null ) | |||
| { | |||
| throw new TaskException( "Cannot execute a jar in non-forked mode." ); | |||
| } | |||
| if( m_vmArgs.size() > 0 ) | |||
| { | |||
| context.warn( "JVM args ignored when same JVM is used." ); | |||
| } | |||
| if( m_workingDirectory != null ) | |||
| { | |||
| context.warn( "Working directory ignored when same JVM is used." ); | |||
| } | |||
| if( m_sysProperties.size() > 0 ) | |||
| { | |||
| context.warn( "System properties ignored when same JVM is used." ); | |||
| } | |||
| final String[] args = m_args.getArguments(); | |||
| context.debug( "Running in same VM: " + m_className + " " + FileUtils.formatCommandLine( args ) ); | |||
| @@ -182,13 +195,24 @@ public class ExecuteJava | |||
| } | |||
| /** | |||
| * Executes the given classname with the given arguments in a separate VM. | |||
| * Executes the application in a separate JVM. | |||
| */ | |||
| private void execForked( final TaskContext context ) | |||
| public int executeForked( final TaskContext context ) | |||
| throws TaskException | |||
| { | |||
| // Validate | |||
| if( m_className != null && m_jar != null ) | |||
| { | |||
| throw new TaskException( "Only one of Classname and Jar can be set." ); | |||
| } | |||
| else if( m_className == null && m_jar == null ) | |||
| { | |||
| throw new TaskException( "Classname must not be null." ); | |||
| } | |||
| final Execute exe = new Execute(); | |||
| exe.setWorkingDirectory( m_workingDirectory ); | |||
| exe.setIgnoreReturnCode( m_ignoreReturnCode ); | |||
| // Setup the command line | |||
| final Commandline command = exe.getCommandline(); | |||
| @@ -204,8 +228,7 @@ public class ExecuteJava | |||
| } | |||
| // JVM arguments | |||
| final String[] vmArgs = m_vmArgs.getArguments(); | |||
| command.addArguments( vmArgs ); | |||
| command.addArguments( m_vmArgs ); | |||
| // Max memory size | |||
| if( m_maxMemory != null ) | |||
| @@ -214,7 +237,7 @@ public class ExecuteJava | |||
| } | |||
| // System properties | |||
| final String[] props = m_sysProperties.getJavaVariables(); | |||
| final String[] props = SysProperties.getJavaVariables( m_sysProperties ); | |||
| command.addArguments( props ); | |||
| // Classpath | |||
| @@ -236,11 +259,10 @@ public class ExecuteJava | |||
| } | |||
| // Java app arguments | |||
| final String[] args = m_args.getArguments(); | |||
| command.addArguments( args ); | |||
| command.addArguments( m_args ); | |||
| // Execute | |||
| exe.execute( context ); | |||
| return exe.execute( context ); | |||
| } | |||
| /** | |||
| @@ -10,13 +10,9 @@ package org.apache.tools.todo.taskdefs.javacc; | |||
| import java.io.File; | |||
| import java.util.Enumeration; | |||
| import java.util.Hashtable; | |||
| import org.apache.aut.nativelib.ExecManager; | |||
| import org.apache.myrmidon.api.AbstractTask; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.api.TaskContext; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.taskdefs.ExecuteJava; | |||
| import org.apache.tools.todo.types.Path; | |||
| import org.apache.tools.todo.types.PathUtil; | |||
| @@ -51,14 +47,6 @@ public class JJTree | |||
| private File target = null; | |||
| private File javaccHome = null; | |||
| private CommandlineJava cmdl = new CommandlineJava(); | |||
| public JJTree() | |||
| { | |||
| cmdl.setVm( "java" ); | |||
| cmdl.setClassname( "COM.sun.labs.jjtree.Main" ); | |||
| } | |||
| public void setBuildnodefiles( boolean buildNodeFiles ) | |||
| { | |||
| optionalAttrs.put( BUILD_NODE_FILES, new Boolean( buildNodeFiles ) ); | |||
| @@ -132,6 +120,8 @@ public class JJTree | |||
| public void execute() | |||
| throws TaskException | |||
| { | |||
| final ExecuteJava exe = new ExecuteJava(); | |||
| exe.setClassName( "COM.sun.labs.jjtree.Main" ); | |||
| // load command line with optional attributes | |||
| Enumeration iter = optionalAttrs.keys(); | |||
| @@ -139,7 +129,7 @@ public class JJTree | |||
| { | |||
| String name = (String)iter.nextElement(); | |||
| Object value = optionalAttrs.get( name ); | |||
| cmdl.addArgument( "-" + name + ":" + value.toString() ); | |||
| exe.getArguments().addArgument( "-" + name + ":" + value.toString() ); | |||
| } | |||
| if( target == null || !target.isFile() ) | |||
| @@ -150,15 +140,16 @@ public class JJTree | |||
| // use the directory containing the target as the output directory | |||
| if( outputDirectory == null ) | |||
| { | |||
| outputDirectory = new File( target.getParent() ); | |||
| outputDirectory = target.getParentFile(); | |||
| } | |||
| if( !outputDirectory.isDirectory() ) | |||
| { | |||
| throw new TaskException( "'outputdirectory' " + outputDirectory + " is not a directory." ); | |||
| } | |||
| // convert backslashes to slashes, otherwise jjtree will put this as | |||
| // comments and this seems to confuse javacc | |||
| cmdl.addArgument( "-OUTPUT_DIRECTORY:" + outputDirectory.getAbsolutePath().replace( '\\', '/' ) ); | |||
| exe.getArguments().addArgument( "-OUTPUT_DIRECTORY:" + outputDirectory.getAbsolutePath().replace( '\\', '/' ) ); | |||
| String targetName = target.getName(); | |||
| final File javaFile = new File( outputDirectory, | |||
| @@ -168,22 +159,19 @@ public class JJTree | |||
| getContext().info( "Target is already built - skipping (" + target + ")" ); | |||
| return; | |||
| } | |||
| cmdl.addArgument( target.getAbsolutePath() ); | |||
| exe.getArguments().addArgument( target ); | |||
| if( javaccHome == null || !javaccHome.isDirectory() ) | |||
| { | |||
| throw new TaskException( "Javacchome not set." ); | |||
| } | |||
| final Path classpath = cmdl.createClasspath(); | |||
| final Path classpath = exe.getClassPath(); | |||
| classpath.addLocation( new File( javaccHome, "JavaCC.zip" ) ); | |||
| PathUtil.addJavaRuntime( classpath ); | |||
| cmdl.addVmArgument( "-mx140M" ); | |||
| cmdl.addVmArgument( "-Dinstall.root=" + javaccHome.getAbsolutePath() ); | |||
| exe.setMaxMemory( "140M" ); | |||
| exe.getSysProperties().addVariable( "install.root", javaccHome.getAbsolutePath() ); | |||
| final Execute exe = new Execute(); | |||
| getContext().debug( cmdl.toString() ); | |||
| exe.setCommandline( new Commandline( cmdl.getCommandline() ) ); | |||
| exe.execute( getContext() ); | |||
| exe.executeForked( getContext() ); | |||
| } | |||
| } | |||
| @@ -10,13 +10,9 @@ package org.apache.tools.todo.taskdefs.javacc; | |||
| import java.io.File; | |||
| import java.util.Enumeration; | |||
| import java.util.Hashtable; | |||
| import org.apache.aut.nativelib.ExecManager; | |||
| import org.apache.myrmidon.api.AbstractTask; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.api.TaskContext; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.taskdefs.ExecuteJava; | |||
| import org.apache.tools.todo.types.Path; | |||
| import org.apache.tools.todo.types.PathUtil; | |||
| @@ -61,14 +57,6 @@ public class JavaCC | |||
| private File target = null; | |||
| private File javaccHome = null; | |||
| private CommandlineJava cmdl = new CommandlineJava(); | |||
| public JavaCC() | |||
| { | |||
| cmdl.setVm( "java" ); | |||
| cmdl.setClassname( "COM.sun.labs.javacc.Main" ); | |||
| } | |||
| public void setBuildparser( boolean buildParser ) | |||
| { | |||
| optionalAttrs.put( BUILD_PARSER, new Boolean( buildParser ) ); | |||
| @@ -187,16 +175,6 @@ public class JavaCC | |||
| public void execute() | |||
| throws TaskException | |||
| { | |||
| // load command line with optional attributes | |||
| Enumeration iter = optionalAttrs.keys(); | |||
| while( iter.hasMoreElements() ) | |||
| { | |||
| String name = (String)iter.nextElement(); | |||
| Object value = optionalAttrs.get( name ); | |||
| cmdl.addArgument( "-" + name + ":" + value.toString() ); | |||
| } | |||
| // check the target is a file | |||
| if( target == null || !target.isFile() ) | |||
| { | |||
| @@ -206,13 +184,17 @@ public class JavaCC | |||
| // use the directory containing the target as the output directory | |||
| if( outputDirectory == null ) | |||
| { | |||
| outputDirectory = new File( target.getParent() ); | |||
| outputDirectory = target.getParentFile(); | |||
| } | |||
| else if( !outputDirectory.isDirectory() ) | |||
| if( !outputDirectory.isDirectory() ) | |||
| { | |||
| throw new TaskException( "Outputdir not a directory." ); | |||
| } | |||
| cmdl.addArgument( "-OUTPUT_DIRECTORY:" + outputDirectory.getAbsolutePath() ); | |||
| if( javaccHome == null || !javaccHome.isDirectory() ) | |||
| { | |||
| throw new TaskException( "Javacchome not set." ); | |||
| } | |||
| // determine if the generated java file is up-to-date | |||
| final File javaFile = getOutputJavaFile( outputDirectory, target ); | |||
| @@ -221,30 +203,31 @@ public class JavaCC | |||
| getContext().debug( "Target is already built - skipping (" + target + ")" ); | |||
| return; | |||
| } | |||
| cmdl.addArgument( target.getAbsolutePath() ); | |||
| if( javaccHome == null || !javaccHome.isDirectory() ) | |||
| ExecuteJava exe = new ExecuteJava(); | |||
| exe.setClassName( "COM.sun.labs.javacc.Main" ); | |||
| // load command line with optional attributes | |||
| Enumeration iter = optionalAttrs.keys(); | |||
| while( iter.hasMoreElements() ) | |||
| { | |||
| throw new TaskException( "Javacchome not set." ); | |||
| String name = (String)iter.nextElement(); | |||
| Object value = optionalAttrs.get( name ); | |||
| exe.getArguments().addArgument( "-" + name + ":" + value.toString() ); | |||
| } | |||
| final Path classpath = cmdl.createClasspath(); | |||
| exe.getArguments().addArgument( "-OUTPUT_DIRECTORY:" + outputDirectory.getAbsolutePath() ); | |||
| exe.getArguments().addArgument( target ); | |||
| final Path classpath = exe.getClassPath(); | |||
| classpath.addLocation( new File( javaccHome, "JavaCC.zip" ) ); | |||
| PathUtil.addJavaRuntime( classpath ); | |||
| cmdl.addVmArgument( "-mx140M" ); | |||
| cmdl.addVmArgument( "-Dinstall.root=" + javaccHome.getAbsolutePath() ); | |||
| exe.setMaxMemory( "140M" ); | |||
| exe.getSysProperties().addVariable( "install.root", javaccHome.getAbsolutePath() ); | |||
| runCommand( cmdl ); | |||
| } | |||
| private void runCommand( final CommandlineJava cmdline ) | |||
| throws TaskException | |||
| { | |||
| getContext().debug( cmdline.toString() ); | |||
| final Execute exe = new Execute(); | |||
| final String[] commandline = cmdline.getCommandline(); | |||
| exe.setCommandline( new Commandline( commandline ) ); | |||
| exe.execute( getContext() ); | |||
| exe.executeForked( getContext() ); | |||
| } | |||
| /** | |||
| @@ -13,12 +13,8 @@ import java.io.IOException; | |||
| import java.io.PrintWriter; | |||
| import org.apache.myrmidon.api.AbstractTask; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.taskdefs.ExecuteJava; | |||
| import org.apache.tools.todo.types.Path; | |||
| import org.apache.tools.todo.types.PathUtil; | |||
| import org.apache.tools.todo.util.FileUtils; | |||
| /** | |||
| * Ant task to run JDepend tests. <p> | |||
| @@ -38,7 +34,7 @@ public class JDependTask | |||
| private boolean m_fork; | |||
| private String m_jvm; | |||
| private String m_format = "text"; | |||
| private Path m_compileClasspath; | |||
| private Path m_compileClasspath = new Path(); | |||
| private File m_dir; | |||
| private File m_outputFile; | |||
| private Path m_sourcesPath; | |||
| @@ -49,14 +45,7 @@ public class JDependTask | |||
| public void setClasspath( final Path classpath ) | |||
| throws TaskException | |||
| { | |||
| if( m_compileClasspath == null ) | |||
| { | |||
| m_compileClasspath = classpath; | |||
| } | |||
| else | |||
| { | |||
| m_compileClasspath.addPath( classpath ); | |||
| } | |||
| addClasspath( classpath ); | |||
| } | |||
| /** | |||
| @@ -112,20 +101,11 @@ public class JDependTask | |||
| } | |||
| /** | |||
| * Maybe creates a nested classpath element. | |||
| * | |||
| * @return Description of the Returned Value | |||
| * Adds a nested classpath element. | |||
| */ | |||
| public Path createClasspath() | |||
| public void addClasspath( final Path path ) | |||
| { | |||
| if( m_compileClasspath == null ) | |||
| { | |||
| m_compileClasspath = new Path(); | |||
| } | |||
| Path path1 = m_compileClasspath; | |||
| final Path path = new Path(); | |||
| path1.addPath( path ); | |||
| return path; | |||
| m_compileClasspath.addPath( path ); | |||
| } | |||
| /** | |||
| @@ -146,22 +126,6 @@ public class JDependTask | |||
| public void execute() | |||
| throws TaskException | |||
| { | |||
| final CommandlineJava commandline = new CommandlineJava(); | |||
| if( "text".equals( m_format ) ) | |||
| { | |||
| commandline.setClassname( "jdepend.textui.JDepend" ); | |||
| } | |||
| else if( "xml".equals( m_format ) ) | |||
| { | |||
| commandline.setClassname( "jdepend.xmlui.JDepend" ); | |||
| } | |||
| if( m_jvm != null ) | |||
| { | |||
| commandline.setVm( m_jvm ); | |||
| } | |||
| if( m_sourcesPath == null ) | |||
| { | |||
| throw new TaskException( "Missing Sourcepath required argument" ); | |||
| @@ -170,11 +134,11 @@ public class JDependTask | |||
| // execute the test and get the return code | |||
| if( !m_fork ) | |||
| { | |||
| executeInVM( commandline ); | |||
| executeInVM(); | |||
| } | |||
| else | |||
| { | |||
| executeAsForked( commandline ); | |||
| executeAsForked(); | |||
| } | |||
| } | |||
| @@ -185,28 +149,35 @@ public class JDependTask | |||
| * killedProcess()</tt> method of the watchdog class. | |||
| */ | |||
| // JL: comment extracted from JUnitTask (and slightly modified) | |||
| private void executeAsForked( final CommandlineJava commandline ) | |||
| private void executeAsForked() | |||
| throws TaskException | |||
| { | |||
| // if not set, auto-create the ClassPath from the project | |||
| createClasspath(); | |||
| final ExecuteJava exe = new ExecuteJava(); | |||
| exe.setWorkingDirectory( m_dir ); | |||
| // not sure whether this test is needed but cost nothing to put. | |||
| // hope it will be reviewed by anybody competent | |||
| final String compileClasspath = PathUtil.formatPath( m_compileClasspath ); | |||
| if( compileClasspath.length() > 0 ) | |||
| if( "text".equals( m_format ) ) | |||
| { | |||
| exe.setClassName( "jdepend.textui.JDepend" ); | |||
| } | |||
| else | |||
| { | |||
| exe.setClassName( "jdepend.xmlui.JDepend" ); | |||
| } | |||
| if( m_jvm != null ) | |||
| { | |||
| commandline.addVmArgument( "-classpath" ); | |||
| commandline.addVmArgument( compileClasspath ); | |||
| exe.setJvm( m_jvm ); | |||
| } | |||
| exe.getClassPath().addPath( m_compileClasspath ); | |||
| if( m_outputFile != null ) | |||
| { | |||
| // having a space between the file and its path causes commandline to add quotes " | |||
| // around the argument thus making JDepend not taking it into account. Thus we split it in two | |||
| commandline.addArgument( "-file" ); | |||
| commandline.addArgument( m_outputFile.getPath() ); | |||
| // we have to find a cleaner way to put this output | |||
| exe.getArguments().addArgument( "-file" ); | |||
| exe.getArguments().addArgument( m_outputFile ); | |||
| getContext().info( "Output to be stored in " + m_outputFile.getPath() ); | |||
| } | |||
| final String[] elements = m_sourcesPath.list(); | |||
| @@ -219,20 +190,10 @@ public class JDependTask | |||
| { | |||
| throw new TaskException( "\"" + f.getPath() + "\" does not represent a valid directory. JDepend would fail." ); | |||
| } | |||
| commandline.addArgument( f.getPath() ); | |||
| exe.getArguments().addArgument( f ); | |||
| } | |||
| final Execute exe = new Execute(); | |||
| final String[] commandline1 = commandline.getCommandline(); | |||
| exe.setCommandline( new Commandline( commandline1 ) ); | |||
| exe.setWorkingDirectory( m_dir ); | |||
| if( m_outputFile != null ) | |||
| { | |||
| getContext().info( "Output to be stored in " + m_outputFile.getPath() ); | |||
| } | |||
| exe.execute( getContext() ); | |||
| exe.executeForked( getContext() ); | |||
| } | |||
| @@ -243,11 +204,8 @@ public class JDependTask | |||
| /** | |||
| * Execute inside VM. | |||
| * | |||
| * @param commandline Description of Parameter | |||
| * @exception TaskException Description of Exception | |||
| */ | |||
| private void executeInVM( final CommandlineJava commandline ) | |||
| private void executeInVM() | |||
| throws TaskException | |||
| { | |||
| jdepend.textui.JDepend jdepend; | |||
| @@ -218,11 +218,10 @@ public class WLJspc extends MatchingTask | |||
| args[ j + 2 ] = sourceDirectory + File.separator + (String)filesToDo.get( i ); | |||
| ExecuteJava helperTask = new ExecuteJava(); | |||
| helperTask.setFork( true ); | |||
| helperTask.setClassName( "weblogic.jspc" ); | |||
| helperTask.getArguments().addArguments( args ); | |||
| helperTask.getClassPath().addPath( compileClasspath ); | |||
| helperTask.execute( getContext() ); | |||
| helperTask.executeForked( getContext() ); | |||
| } | |||
| } | |||
| @@ -14,22 +14,20 @@ import java.net.URL; | |||
| import java.net.URLClassLoader; | |||
| import java.util.ArrayList; | |||
| import java.util.Iterator; | |||
| import java.util.Map; | |||
| import java.util.Properties; | |||
| import java.util.Random; | |||
| import org.apache.aut.nativelib.ExecManager; | |||
| import org.apache.myrmidon.api.AbstractTask; | |||
| import org.apache.myrmidon.api.TaskContext; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.taskdefs.ExecuteJava; | |||
| import org.apache.tools.todo.types.Argument; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.types.EnumeratedAttribute; | |||
| import org.apache.tools.todo.types.EnvironmentVariable; | |||
| import org.apache.tools.todo.types.Path; | |||
| import org.apache.tools.todo.types.PathUtil; | |||
| import org.apache.tools.todo.types.SysProperties; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.EnvironmentData; | |||
| /** | |||
| * Ant task to run JUnit tests. <p> | |||
| @@ -102,28 +100,20 @@ import org.apache.tools.todo.types.SysProperties; | |||
| */ | |||
| public class JUnitTask extends AbstractTask | |||
| { | |||
| private CommandlineJava commandline = new CommandlineJava(); | |||
| private ArrayList tests = new ArrayList(); | |||
| private ArrayList batchTests = new ArrayList(); | |||
| private ArrayList formatters = new ArrayList(); | |||
| private File dir = null; | |||
| private Integer timeout = null; | |||
| private boolean summary = false; | |||
| private String summaryValue = ""; | |||
| private JUnitTestRunner runner = null; | |||
| /** | |||
| * Creates a new JUnitRunner and enables fork of a new Java VM. | |||
| * | |||
| * @exception Exception Description of Exception | |||
| */ | |||
| public JUnitTask() | |||
| throws Exception | |||
| { | |||
| commandline.setClassname( "org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner" ); | |||
| } | |||
| private File dir; | |||
| private String jvm; | |||
| private String maxMem; | |||
| private EnvironmentData sysProperties = new EnvironmentData(); | |||
| private Path classPath = new Path(); | |||
| private Commandline vmArgs = new Commandline(); | |||
| /** | |||
| * The directory to invoke the VM in. Ignored if no JVM is forked. | |||
| @@ -131,7 +121,7 @@ public class JUnitTask extends AbstractTask | |||
| * @param dir the directory to invoke the JVM from. | |||
| * @see #setFork(boolean) | |||
| */ | |||
| public void setDir( File dir ) | |||
| public void setDir( final File dir ) | |||
| { | |||
| this.dir = dir; | |||
| } | |||
| @@ -252,9 +242,9 @@ public class JUnitTask extends AbstractTask | |||
| * @param value the new VM to use instead of <tt>java</tt> | |||
| * @see #setFork(boolean) | |||
| */ | |||
| public void setJvm( String value ) | |||
| public void setJvm( final String value ) | |||
| { | |||
| commandline.setVm( value ); | |||
| jvm = value; | |||
| } | |||
| /** | |||
| @@ -263,9 +253,9 @@ public class JUnitTask extends AbstractTask | |||
| * @param max the value as defined by <tt>-mx</tt> or <tt>-Xmx</tt> in the | |||
| * java command line options. | |||
| */ | |||
| public void setMaxmemory( String max ) | |||
| public void setMaxmemory( final String max ) | |||
| { | |||
| commandline.addVmArgument( "-Xmx" + max ); | |||
| maxMem = max; | |||
| } | |||
| /** | |||
| @@ -313,7 +303,7 @@ public class JUnitTask extends AbstractTask | |||
| */ | |||
| public void addSysproperty( EnvironmentVariable sysp ) | |||
| { | |||
| commandline.addSysproperty( sysp ); | |||
| sysProperties.addVariable( sysp ); | |||
| } | |||
| /** | |||
| @@ -330,28 +320,18 @@ public class JUnitTask extends AbstractTask | |||
| /** | |||
| * Create a new set of testcases (also called ..batchtest) and add it to the | |||
| * list. | |||
| * | |||
| * @return a new instance of a batch test. | |||
| * @see BatchTest | |||
| */ | |||
| public BatchTest createBatchTest() | |||
| public void addBatchTest( final BatchTest test ) | |||
| { | |||
| BatchTest test = new BatchTest(); | |||
| batchTests.add( test ); | |||
| return test; | |||
| } | |||
| /** | |||
| * <code><classpath></code> allows classpath to be set for tests. | |||
| * | |||
| * @return Description of the Returned Value | |||
| */ | |||
| public Path createClasspath() | |||
| public void addClasspath( final Path path ) | |||
| { | |||
| Path path1 = commandline.createClasspath(); | |||
| final Path path = new Path(); | |||
| path1.addPath( path ); | |||
| return path; | |||
| classPath.addPath( path ); | |||
| } | |||
| /** | |||
| @@ -361,7 +341,7 @@ public class JUnitTask extends AbstractTask | |||
| */ | |||
| public void addJvmarg( final Argument argument ) | |||
| { | |||
| commandline.addVmArgument( argument ); | |||
| vmArgs.addArgument( argument ); | |||
| } | |||
| /** | |||
| @@ -372,6 +352,7 @@ public class JUnitTask extends AbstractTask | |||
| public void execute() | |||
| throws TaskException | |||
| { | |||
| /* | |||
| * Adds the jars or directories containing Ant, this task and JUnit to the | |||
| * classpath - this should make the forked JVM work without having to | |||
| @@ -452,14 +433,14 @@ public class JUnitTask extends AbstractTask | |||
| int pling = u.indexOf( "!" ); | |||
| String jarName = u.substring( 9, pling ); | |||
| getContext().debug( "Implicitly adding " + jarName + " to classpath" ); | |||
| createClasspath().addLocation( new File( jarName ) ); | |||
| classPath.addLocation( new File( jarName ) ); | |||
| } | |||
| else if( u.startsWith( "file:" ) ) | |||
| { | |||
| int tail = u.indexOf( resource ); | |||
| String dirName = u.substring( 5, tail ); | |||
| getContext().debug( "Implicitly adding " + dirName + " to classpath" ); | |||
| createClasspath().addLocation( new File( dirName ) ); | |||
| classPath.addLocation( new File( dirName ) ); | |||
| } | |||
| else | |||
| { | |||
| @@ -484,7 +465,7 @@ public class JUnitTask extends AbstractTask | |||
| * @param test Description of Parameter | |||
| * @exception TaskException Description of Exception | |||
| */ | |||
| protected void execute( JUnitTest test ) | |||
| protected void execute( final JUnitTest test ) | |||
| throws TaskException | |||
| { | |||
| // set the default values if not specified | |||
| @@ -581,17 +562,24 @@ public class JUnitTask extends AbstractTask | |||
| private int executeAsForked( JUnitTest test ) | |||
| throws TaskException | |||
| { | |||
| CommandlineJava cmd = commandline;//(CommandlineJava)commandline.clone(); | |||
| cmd.setClassname( "org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner" ); | |||
| cmd.addArgument( test.getName() ); | |||
| cmd.addArgument( "filtertrace=" + test.getFiltertrace() ); | |||
| cmd.addArgument( "haltOnError=" + test.getHaltonerror() ); | |||
| cmd.addArgument( "haltOnFailure=" + test.getHaltonfailure() ); | |||
| ExecuteJava cmd = new ExecuteJava(); | |||
| cmd.setJvm( jvm ); | |||
| cmd.setIgnoreReturnCode( true ); | |||
| cmd.setWorkingDirectory( dir ); | |||
| cmd.setMaxMemory( maxMem ); | |||
| cmd.getClassPath().addPath( classPath ); | |||
| cmd.getVmArguments().addArguments( vmArgs ); | |||
| cmd.getSysProperties().addVariables( sysProperties ); | |||
| cmd.setClassName( "org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner" ); | |||
| cmd.getArguments().addArgument( test.getName() ); | |||
| cmd.getArguments().addArgument( "filtertrace=" + test.getFiltertrace() ); | |||
| cmd.getArguments().addArgument( "haltOnError=" + test.getHaltonerror() ); | |||
| cmd.getArguments().addArgument( "haltOnFailure=" + test.getHaltonfailure() ); | |||
| if( summary ) | |||
| { | |||
| getContext().info( "Running " + test.getName() ); | |||
| cmd.addArgument( "formatter=org.apache.tools.ant.taskdefs.optional.junit.SummaryJUnitResultFormatter" ); | |||
| cmd.getArguments().addArgument( "formatter=org.apache.tools.ant.taskdefs.optional.junit.SummaryJUnitResultFormatter" ); | |||
| } | |||
| StringBuffer formatterArg = new StringBuffer( 128 ); | |||
| @@ -607,20 +595,15 @@ public class JUnitTask extends AbstractTask | |||
| formatterArg.append( "," ); | |||
| formatterArg.append( outFile ); | |||
| } | |||
| cmd.addArgument( formatterArg.toString() ); | |||
| cmd.getArguments().addArgument( formatterArg.toString() ); | |||
| formatterArg.setLength( 0 ); | |||
| } | |||
| // Create a temporary file to pass the Ant properties to the forked test | |||
| File propsFile = new File( "junit" + ( new Random( System.currentTimeMillis() ) ).nextLong() + ".properties" ); | |||
| cmd.addArgument( "propsfile=" + propsFile.getAbsolutePath() ); | |||
| Map p = getContext().getProperties(); | |||
| cmd.getArguments().addArgument( "propsfile=" + propsFile.getAbsolutePath() ); | |||
| Properties props = new Properties(); | |||
| for( Iterator enum = p.keySet().iterator(); enum.hasNext(); ) | |||
| { | |||
| final Object key = enum.next(); | |||
| props.put( key, p.get( key ) ); | |||
| } | |||
| props.putAll( getContext().getProperties() ); | |||
| try | |||
| { | |||
| final FileOutputStream outstream = new FileOutputStream( propsFile ); | |||
| @@ -632,14 +615,9 @@ public class JUnitTask extends AbstractTask | |||
| throw new TaskException( "Error creating temporary properties file.", ioe ); | |||
| } | |||
| final Execute exe = new Execute(); | |||
| exe.setIgnoreReturnCode( true ); | |||
| exe.setCommandline( new Commandline( cmd.getCommandline() ) ); | |||
| exe.setWorkingDirectory( dir ); | |||
| try | |||
| { | |||
| return exe.execute( getContext() ); | |||
| return cmd.executeForked( getContext() ); | |||
| } | |||
| finally | |||
| { | |||
| @@ -657,25 +635,16 @@ public class JUnitTask extends AbstractTask | |||
| throws TaskException | |||
| { | |||
| test.setProperties( getContext().getProperties() ); | |||
| if( dir != null ) | |||
| { | |||
| getContext().warn( "dir attribute ignored if running in the same VM" ); | |||
| } | |||
| SysProperties sysProperties = commandline.getSystemProperties(); | |||
| if( sysProperties != null ) | |||
| { | |||
| sysProperties.setSystem(); | |||
| } | |||
| SysProperties.setSystem( sysProperties ); | |||
| try | |||
| { | |||
| getContext().debug( "Using System properties " + System.getProperties() ); | |||
| ClassLoader classLoader = null; | |||
| Path classpath = commandline.getClasspath(); | |||
| if( classpath != null ) | |||
| final URL[] urls = PathUtil.toURLs( classPath ); | |||
| if( urls.length > 0 ) | |||
| { | |||
| getContext().debug( "Using CLASSPATH " + classpath ); | |||
| final URL[] urls = PathUtil.toURLs( classpath ); | |||
| classLoader = new URLClassLoader( urls ); | |||
| } | |||
| runner = new JUnitTestRunner( test, | |||
| @@ -715,10 +684,7 @@ public class JUnitTask extends AbstractTask | |||
| } | |||
| finally | |||
| { | |||
| if( sysProperties != null ) | |||
| { | |||
| sysProperties.restoreSystem(); | |||
| } | |||
| SysProperties.restoreSystem(); | |||
| } | |||
| } | |||
| @@ -17,10 +17,8 @@ import java.util.Iterator; | |||
| import java.util.Random; | |||
| import org.apache.myrmidon.api.AbstractTask; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.taskdefs.ExecuteJava; | |||
| import org.apache.tools.todo.types.Argument; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.types.DirectoryScanner; | |||
| import org.apache.tools.todo.types.FileSet; | |||
| import org.apache.tools.todo.types.Path; | |||
| @@ -36,17 +34,10 @@ import org.apache.tools.todo.types.ScannerUtil; | |||
| public abstract class AbstractMetamataTask | |||
| extends AbstractTask | |||
| { | |||
| /** | |||
| * The user classpath to be provided. It matches the -classpath of the | |||
| * command line. The classpath must includes both the <tt>.class</tt> and | |||
| * the <tt>.java</tt> files for accurate audit. | |||
| */ | |||
| private Path m_classPath = new Path(); | |||
| /** | |||
| * the path to the source file | |||
| */ | |||
| private Path m_sourcePath; | |||
| private Path m_sourcePath = new Path(); | |||
| /** | |||
| * Metamata home directory. It will be passed as a <tt>metamata.home</tt> | |||
| @@ -58,7 +49,7 @@ public abstract class AbstractMetamataTask | |||
| /** | |||
| * the command line used to run MAudit | |||
| */ | |||
| private CommandlineJava m_cmdl = new CommandlineJava(); | |||
| private ExecuteJava m_exe = new ExecuteJava(); | |||
| /** | |||
| * the set of files to be audited | |||
| @@ -74,19 +65,14 @@ public abstract class AbstractMetamataTask | |||
| // be set when calling scanFileSets(); | |||
| private Hashtable m_includedFiles; | |||
| public AbstractMetamataTask() | |||
| { | |||
| } | |||
| /** | |||
| * initialize the task with the classname of the task to run | |||
| * | |||
| * @param className Description of Parameter | |||
| */ | |||
| protected AbstractMetamataTask( String className ) | |||
| protected AbstractMetamataTask( final String className ) | |||
| { | |||
| m_cmdl.setVm( "java" ); | |||
| m_cmdl.setClassname( className ); | |||
| m_exe.setClassName( className ); | |||
| } | |||
| /** | |||
| @@ -116,9 +102,9 @@ public abstract class AbstractMetamataTask | |||
| * | |||
| * @param max The new Maxmemory value | |||
| */ | |||
| public void setMaxmemory( String max ) | |||
| public void setMaxmemory( final String max ) | |||
| { | |||
| m_cmdl.addVmArgument( "-Xmx" + max ); | |||
| m_exe.setMaxMemory( max ); | |||
| } | |||
| /** | |||
| @@ -126,7 +112,7 @@ public abstract class AbstractMetamataTask | |||
| */ | |||
| public void setMetamatahome( final File metamataHome ) | |||
| { | |||
| this.m_metamataHome = metamataHome; | |||
| m_metamataHome = metamataHome; | |||
| } | |||
| /** | |||
| @@ -142,7 +128,7 @@ public abstract class AbstractMetamataTask | |||
| */ | |||
| public void addClasspath( final Path path ) | |||
| { | |||
| m_classPath.addPath( path ); | |||
| m_exe.getClassPath().addPath( path ); | |||
| } | |||
| /** | |||
| @@ -150,19 +136,15 @@ public abstract class AbstractMetamataTask | |||
| */ | |||
| public void addJvmarg( final Argument argument ) | |||
| { | |||
| m_cmdl.addVmArgument( argument ); | |||
| m_exe.getVmArguments().addArgument( argument ); | |||
| } | |||
| /** | |||
| * create the source path for this task | |||
| */ | |||
| public Path createSourcepath() | |||
| public void addSourcepath( final Path path ) | |||
| { | |||
| if( m_sourcePath == null ) | |||
| { | |||
| m_sourcePath = new Path(); | |||
| } | |||
| return m_sourcePath; | |||
| m_sourcePath.addPath( path ); | |||
| } | |||
| /** | |||
| @@ -194,11 +176,11 @@ public abstract class AbstractMetamataTask | |||
| // set the classpath as the jar file | |||
| File jar = getMetamataJar( m_metamataHome ); | |||
| final Path classPath = m_cmdl.createClasspath(); | |||
| final Path classPath = m_exe.getClassPath(); | |||
| classPath.addLocation( jar ); | |||
| // set the metamata.home property | |||
| m_cmdl.addVmArgument( "-Dmetamata.home=" + m_metamataHome.getAbsolutePath() ); | |||
| m_exe.getSysProperties().addVariable( "metamata.home", m_metamataHome.getAbsolutePath() ); | |||
| // retrieve all the files we want to scan | |||
| m_includedFiles = scanFileSets(); | |||
| @@ -208,8 +190,8 @@ public abstract class AbstractMetamataTask | |||
| ArrayList options = getOptions(); | |||
| m_optionsFile = createTmpFile(); | |||
| generateOptionsFile( m_optionsFile, options ); | |||
| m_cmdl.addArgument( "-arguments " ); | |||
| m_cmdl.addArgument( m_optionsFile.getAbsolutePath() ); | |||
| m_exe.getArguments().addArgument( "-arguments" ); | |||
| m_exe.getArguments().addArgument( m_optionsFile ); | |||
| } | |||
| /** | |||
| @@ -271,11 +253,7 @@ public abstract class AbstractMetamataTask | |||
| protected void execute0() | |||
| throws TaskException | |||
| { | |||
| final Execute exe = new Execute(); | |||
| getContext().debug( m_cmdl.toString() ); | |||
| final String[] commandline = m_cmdl.getCommandline(); | |||
| exe.setCommandline( new Commandline( commandline ) ); | |||
| exe.execute( getContext() ); | |||
| m_exe.executeForked( getContext() ); | |||
| } | |||
| protected void generateOptionsFile( File tofile, ArrayList options ) | |||
| @@ -355,17 +333,11 @@ public abstract class AbstractMetamataTask | |||
| protected Path getClassPath() | |||
| { | |||
| return m_classPath; | |||
| return m_exe.getClassPath(); | |||
| } | |||
| protected Path getSourcePath() | |||
| { | |||
| return m_sourcePath; | |||
| } | |||
| protected void setSourcePath( Path sourcePath ) | |||
| { | |||
| m_sourcePath = sourcePath; | |||
| } | |||
| } | |||
| @@ -124,12 +124,7 @@ public class MAudit | |||
| // there is a bug in Metamata 2.0 build 37. The sourcepath argument does | |||
| // not work. So we will use the sourcepath prepended to classpath. (order | |||
| // is important since Metamata looks at .class and .java) | |||
| final Path sourcePath = getSourcePath(); | |||
| if( sourcePath != null ) | |||
| { | |||
| classpath.addPath( sourcePath ); | |||
| setSourcePath( null );// prevent from using -sourcepath | |||
| } | |||
| classpath.addPath( getSourcePath() ); | |||
| // don't forget to modify the pattern if you change the options reporting | |||
| classpath.addPath( getClassPath() ); | |||
| @@ -157,11 +152,12 @@ public class MAudit | |||
| { | |||
| options.add( "-list" ); | |||
| } | |||
| if( getSourcePath() != null ) | |||
| { | |||
| options.add( "-sourcepath" ); | |||
| options.add( PathUtil.formatPath( getSourcePath() ) ); | |||
| } | |||
| //if( getSourcePath() != null ) | |||
| //{ | |||
| // options.add( "-sourcepath" ); | |||
| // options.add( PathUtil.formatPath( getSourcePath() ) ); | |||
| //} | |||
| if( m_unused ) | |||
| { | |||
| @@ -127,11 +127,7 @@ public class MMetrics extends AbstractMetamataTask | |||
| // there is a bug in Metamata 2.0 build 37. The sourcepath argument does | |||
| // not work. So we will use the sourcepath prepended to classpath. (order | |||
| // is important since Metamata looks at .class and .java) | |||
| if( getSourcePath() != null ) | |||
| { | |||
| classpath.addPath( getSourcePath() ); | |||
| setSourcePath( null );// prevent from using -sourcepath | |||
| } | |||
| classpath.addPath( getSourcePath() ); | |||
| // don't forget to modify the pattern if you change the options reporting | |||
| classpath.addPath( getClassPath() ); | |||
| @@ -16,10 +16,8 @@ import java.util.Random; | |||
| import org.apache.avalon.excalibur.io.IOUtil; | |||
| import org.apache.myrmidon.api.AbstractTask; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.taskdefs.ExecuteJava; | |||
| import org.apache.tools.todo.types.Argument; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.types.Path; | |||
| import org.apache.tools.todo.types.PathUtil; | |||
| @@ -34,23 +32,17 @@ import org.apache.tools.todo.types.PathUtil; | |||
| public class MParse | |||
| extends AbstractTask | |||
| { | |||
| private Path m_classpath; | |||
| private Path m_sourcepath; | |||
| private Path m_classpath = new Path(); | |||
| private Path m_sourcepath = new Path(); | |||
| private File m_metahome; | |||
| private File m_target; | |||
| private boolean m_verbose; | |||
| private boolean m_debugparser; | |||
| private boolean m_debugscanner; | |||
| private boolean m_cleanup; | |||
| private CommandlineJava m_cmdl = new CommandlineJava(); | |||
| private ExecuteJava m_exe = new ExecuteJava(); | |||
| private File m_optionsFile; | |||
| public MParse() | |||
| { | |||
| m_cmdl.setVm( "java" ); | |||
| m_cmdl.setClassname( "com.metamata.jj.MParse" ); | |||
| } | |||
| /** | |||
| * create a temporary file in the current directory | |||
| * | |||
| @@ -101,7 +93,7 @@ public class MParse | |||
| */ | |||
| public void setMaxmemory( String max ) | |||
| { | |||
| m_cmdl.addVmArgument( "-Xmx" + max ); | |||
| m_exe.setMaxMemory( max ); | |||
| } | |||
| /** | |||
| @@ -111,7 +103,7 @@ public class MParse | |||
| */ | |||
| public void setMetamatahome( File metamatahome ) | |||
| { | |||
| this.m_metahome = metamatahome; | |||
| m_metahome = metamatahome; | |||
| } | |||
| /** | |||
| @@ -121,7 +113,7 @@ public class MParse | |||
| */ | |||
| public void setTarget( File target ) | |||
| { | |||
| this.m_target = target; | |||
| m_target = target; | |||
| } | |||
| /** | |||
| @@ -137,15 +129,10 @@ public class MParse | |||
| /** | |||
| * create a classpath entry | |||
| * | |||
| * @return Description of the Returned Value | |||
| */ | |||
| public Path createClasspath() | |||
| public void addClasspath( final Path path ) | |||
| { | |||
| if( m_classpath == null ) | |||
| { | |||
| m_classpath = new Path(); | |||
| } | |||
| return m_classpath; | |||
| m_classpath.addPath( path ); | |||
| } | |||
| /** | |||
| @@ -153,21 +140,15 @@ public class MParse | |||
| */ | |||
| public void addJvmarg( final Argument argument ) | |||
| { | |||
| m_cmdl.addVmArgument( argument ); | |||
| m_exe.getVmArguments().addArgument( argument ); | |||
| } | |||
| /** | |||
| * creates a sourcepath entry | |||
| * | |||
| * @return Description of the Returned Value | |||
| */ | |||
| public Path createSourcepath() | |||
| public void addSourcepath( final Path path ) | |||
| { | |||
| if( m_sourcepath == null ) | |||
| { | |||
| m_sourcepath = new Path(); | |||
| } | |||
| return m_sourcepath; | |||
| m_sourcepath.addPath( path ); | |||
| } | |||
| /** | |||
| @@ -201,21 +182,21 @@ public class MParse | |||
| // set the classpath as the jar files | |||
| File[] jars = getMetamataLibs(); | |||
| final Path classPath = m_cmdl.createClasspath(); | |||
| final Path classPath = m_exe.getClassPath(); | |||
| for( int i = 0; i < jars.length; i++ ) | |||
| { | |||
| classPath.addLocation( jars[ i ] ); | |||
| } | |||
| // set the metamata.home property | |||
| m_cmdl.addVmArgument( "-Dmetamata.home=" + m_metahome.getAbsolutePath() ); | |||
| m_exe.getSysProperties().addVariable( "metamata.home", m_metahome.getAbsolutePath() ); | |||
| // write all the options to a temp file and use it ro run the process | |||
| String[] options = getOptions(); | |||
| m_optionsFile = createTmpFile(); | |||
| generateOptionsFile( m_optionsFile, options ); | |||
| m_cmdl.addArgument( "-arguments" ); | |||
| m_cmdl.addArgument( m_optionsFile.getAbsolutePath() ); | |||
| m_exe.getArguments().addArgument( "-arguments" ); | |||
| m_exe.getArguments().addArgument( m_optionsFile ); | |||
| } | |||
| /** | |||
| @@ -254,12 +235,12 @@ public class MParse | |||
| { | |||
| options.add( "-dp" ); | |||
| } | |||
| if( m_classpath != null ) | |||
| if( ! m_classpath.isEmpty() ) | |||
| { | |||
| options.add( "-classpath" ); | |||
| options.add( PathUtil.formatPath( m_classpath ) ); | |||
| } | |||
| if( m_sourcepath != null ) | |||
| if( ! m_sourcepath.isEmpty() ) | |||
| { | |||
| options.add( "-sourcepath" ); | |||
| options.add( PathUtil.formatPath( m_sourcepath ) ); | |||
| @@ -287,11 +268,8 @@ public class MParse | |||
| return; | |||
| } | |||
| final Execute exe = new Execute(); | |||
| getContext().debug( m_cmdl.toString() ); | |||
| final String[] commandline = m_cmdl.getCommandline(); | |||
| exe.setCommandline( new Commandline( commandline ) ); | |||
| exe.execute( getContext() ); | |||
| m_exe.setClassName( "com.metamata.jj.MParse" ); | |||
| m_exe.executeForked( getContext() ); | |||
| } | |||
| /** | |||
| @@ -18,7 +18,6 @@ import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.myrmidon.framework.Execute; | |||
| import org.apache.tools.todo.types.Argument; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.types.CommandlineJava; | |||
| import org.apache.tools.todo.types.FileSet; | |||
| import org.apache.tools.todo.types.Path; | |||
| import org.apache.tools.todo.types.PathUtil; | |||
| @@ -37,9 +36,6 @@ import org.apache.tools.todo.types.PathUtil; | |||
| public class Coverage | |||
| extends AbstractTask | |||
| { | |||
| protected Commandline cmdl = new Commandline(); | |||
| protected CommandlineJava cmdlJava = new CommandlineJava(); | |||
| /** | |||
| * this is a somewhat annoying thing, set it to never | |||
| */ | |||
| @@ -60,6 +56,10 @@ public class Coverage | |||
| private Triggers m_triggers; | |||
| private String m_vm; | |||
| private File m_workingDir; | |||
| private String m_className; | |||
| private Commandline m_args = new Commandline(); | |||
| private Path m_classpath = new Path(); | |||
| private Commandline m_vmArgs = new Commandline(); | |||
| /** | |||
| * classname to run as standalone or runner for filesets | |||
| @@ -68,7 +68,7 @@ public class Coverage | |||
| */ | |||
| public void setClassname( String value ) | |||
| { | |||
| cmdlJava.setClassname( value ); | |||
| m_className = value; | |||
| } | |||
| /** | |||
| @@ -176,20 +176,15 @@ public class Coverage | |||
| */ | |||
| public void addArg( final Argument argument ) | |||
| { | |||
| cmdlJava.addArgument( argument ); | |||
| m_args.addArgument( argument ); | |||
| } | |||
| /** | |||
| * classpath to run the files | |||
| * | |||
| * @return Description of the Returned Value | |||
| */ | |||
| public Path createClasspath() | |||
| public void setClasspath( final Path path ) | |||
| { | |||
| Path path1 = cmdlJava.createClasspath(); | |||
| final Path path = new Path(); | |||
| path1.addPath( path ); | |||
| return path; | |||
| m_classpath.addPath( path ); | |||
| } | |||
| public Filters createFilters() | |||
| @@ -202,7 +197,7 @@ public class Coverage | |||
| */ | |||
| public void addJvmarg( final Argument argument ) | |||
| { | |||
| cmdlJava.addVmArgument( argument ); | |||
| m_vmArgs.addArgument( argument ); | |||
| } | |||
| public Socket createSocket() | |||
| @@ -245,11 +240,12 @@ public class Coverage | |||
| try | |||
| { | |||
| // we need to run Coverage from his directory due to dll/jar issues | |||
| final Execute exe = new Execute(); | |||
| final Commandline cmdl = exe.getCommandline(); | |||
| cmdl.setExecutable( new File( m_home, "jplauncher" ).getAbsolutePath() ); | |||
| cmdl.addArgument( "-jp_input=" + paramfile.getAbsolutePath() ); | |||
| // use the custom handler for stdin issues | |||
| final Execute exe = new Execute(); | |||
| exe.setCommandline( cmdl ); | |||
| exe.execute( getContext() ); | |||
| } | |||
| @@ -273,62 +269,55 @@ public class Coverage | |||
| protected String[] getParameters() | |||
| throws TaskException | |||
| { | |||
| ArrayList params = new ArrayList(); | |||
| params.add( "-jp_function=coverage" ); | |||
| Commandline params = new Commandline(); | |||
| params.addArgument( "-jp_function=coverage" ); | |||
| if( m_vm != null ) | |||
| { | |||
| params.add( "-jp_vm=" + m_vm ); | |||
| params.addArgument( "-jp_vm=" + m_vm ); | |||
| } | |||
| if( m_javaExe != null ) | |||
| { | |||
| params.add( "-jp_java_exe=" + getContext().resolveFile( m_javaExe.getPath() ) ); | |||
| params.addArgument( "-jp_java_exe=" + m_javaExe.getPath() ); | |||
| } | |||
| params.add( "-jp_working_dir=" + m_workingDir.getPath() ); | |||
| params.add( "-jp_snapshot_dir=" + m_snapshotDir.getPath() ); | |||
| params.add( "-jp_record_from_start=" + m_recordFromStart ); | |||
| params.add( "-jp_warn=" + m_warnLevel ); | |||
| params.addArgument( "-jp_working_dir=" + m_workingDir.getPath() ); | |||
| params.addArgument( "-jp_snapshot_dir=" + m_snapshotDir.getPath() ); | |||
| params.addArgument( "-jp_record_from_start=" + m_recordFromStart ); | |||
| params.addArgument( "-jp_warn=" + m_warnLevel ); | |||
| if( m_seedName != null ) | |||
| { | |||
| params.add( "-jp_output_file=" + m_seedName ); | |||
| params.addArgument( "-jp_output_file=" + m_seedName ); | |||
| } | |||
| params.add( "-jp_filter=" + m_filters.toString() ); | |||
| params.addArgument( "-jp_filter=" + m_filters.toString() ); | |||
| if( m_triggers != null ) | |||
| { | |||
| params.add( "-jp_trigger=" + m_triggers.toString() ); | |||
| params.addArgument( "-jp_trigger=" + m_triggers.toString() ); | |||
| } | |||
| if( m_finalSnapshot != null ) | |||
| { | |||
| params.add( "-jp_final_snapshot=" + m_finalSnapshot ); | |||
| params.addArgument( "-jp_final_snapshot=" + m_finalSnapshot ); | |||
| } | |||
| params.add( "-jp_exit_prompt=" + m_exitPrompt ); | |||
| params.addArgument( "-jp_exit_prompt=" + m_exitPrompt ); | |||
| //params.add("-jp_append=" + append); | |||
| params.add( "-jp_track_natives=" + m_trackNatives ); | |||
| params.addArgument( "-jp_track_natives=" + m_trackNatives ); | |||
| //.... now the jvm | |||
| // arguments | |||
| String[] vmargs = cmdlJava.getVmCommand().getArguments(); | |||
| for( int i = 0; i < vmargs.length; i++ ) | |||
| { | |||
| params.add( vmargs[ i ] ); | |||
| } | |||
| params.addArguments( m_vmArgs ); | |||
| // classpath | |||
| Path classpath = cmdlJava.getClasspath(); | |||
| if( classpath != null && ! classpath.isEmpty() ) | |||
| if( ! m_classpath.isEmpty() ) | |||
| { | |||
| params.add( "-classpath " + PathUtil.formatPath( classpath ) ); | |||
| params.addArgument( "-classpath" ); | |||
| params.addArgument( PathUtil.formatPath( m_classpath ) ); | |||
| } | |||
| // classname (runner or standalone) | |||
| if( cmdlJava.getClassname() != null ) | |||
| if( m_className != null ) | |||
| { | |||
| params.add( cmdlJava.getClassname() ); | |||
| params.addArgument( m_className ); | |||
| } | |||
| // arguments for classname | |||
| String[] args = cmdlJava.getJavaCommand().getArguments(); | |||
| for( int i = 0; i < args.length; i++ ) | |||
| { | |||
| params.add( args[ i ] ); | |||
| } | |||
| params.addArguments( m_args ); | |||
| return (String[])params.toArray( new String[ params.size() ] ); | |||
| return params.getArguments(); | |||
| } | |||
| /** | |||
| @@ -123,6 +123,11 @@ public class Commandline | |||
| } | |||
| } | |||
| public void addArguments( final Commandline cmdline ) | |||
| { | |||
| addArguments( cmdline.getArguments() ); | |||
| } | |||
| public void addArgument( final File argument ) | |||
| { | |||
| addArgument( new Argument( argument ) ); | |||
| @@ -1,263 +0,0 @@ | |||
| /* | |||
| * Copyright (C) The Apache Software Foundation. All rights reserved. | |||
| * | |||
| * This software is published under the terms of the Apache Software License | |||
| * version 1.1, a copy of which has been included with this distribution in | |||
| * the LICENSE.txt file. | |||
| */ | |||
| package org.apache.tools.todo.types; | |||
| import org.apache.avalon.excalibur.util.StringUtil; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.tools.todo.types.Argument; | |||
| import org.apache.tools.todo.types.Commandline; | |||
| import org.apache.tools.todo.taskdefs.ExecuteJava; | |||
| /** | |||
| * A representation of a Java command line that is nothing more than a composite | |||
| * of 2 <tt>Commandline</tt> . 1 for the vm/options and 1 for the | |||
| * classname/arguments. It provides specific methods for a java command line. | |||
| * | |||
| * @author thomas.haas@softwired-inc.com | |||
| * @author <a href="sbailliez@apache.org">Stephane Bailliez</a> | |||
| */ | |||
| public class CommandlineJava | |||
| implements Cloneable | |||
| { | |||
| private Commandline m_vmCommand = new Commandline(); | |||
| private Commandline m_javaCommand = new Commandline(); | |||
| private SysProperties m_sysProperties = new SysProperties(); | |||
| private Path m_classpath; | |||
| private String m_maxMemory; | |||
| /** | |||
| * Indicate whether it will execute a jar file or not, in this case the | |||
| * first vm option must be a -jar and the 'executable' is a jar file. | |||
| */ | |||
| private boolean executeJar; | |||
| public CommandlineJava() | |||
| { | |||
| setVm( ExecuteJava.getJavaExecutableName() ); | |||
| } | |||
| /** | |||
| * set the classname to execute | |||
| * | |||
| * @param classname the fully qualified classname. | |||
| */ | |||
| public void setClassname( String classname ) | |||
| { | |||
| m_javaCommand.setExecutable( classname ); | |||
| executeJar = false; | |||
| } | |||
| /** | |||
| * set a jar file to execute via the -jar option. | |||
| * | |||
| * @param jarpathname The new Jar value | |||
| */ | |||
| public void setJar( String jarpathname ) | |||
| { | |||
| m_javaCommand.setExecutable( jarpathname ); | |||
| executeJar = true; | |||
| } | |||
| /** | |||
| * -mx or -Xmx depending on VM version | |||
| * | |||
| * @param max The new Maxmemory value | |||
| */ | |||
| public void setMaxmemory( String max ) | |||
| { | |||
| m_maxMemory = max; | |||
| } | |||
| public void setSystemProperties() | |||
| throws TaskException | |||
| { | |||
| m_sysProperties.setSystem(); | |||
| } | |||
| public void setVm( String vm ) | |||
| { | |||
| m_vmCommand.setExecutable( vm ); | |||
| } | |||
| /** | |||
| * @return the name of the class to run or <tt>null</tt> if there is no | |||
| * class. | |||
| * @see #getJar() | |||
| */ | |||
| public String getClassname() | |||
| { | |||
| if( !executeJar ) | |||
| { | |||
| return m_javaCommand.getExecutable(); | |||
| } | |||
| return null; | |||
| } | |||
| public Path getClasspath() | |||
| { | |||
| return m_classpath; | |||
| } | |||
| /** | |||
| * get the command line to run a java vm. | |||
| * | |||
| * @return the list of all arguments necessary to run the vm. | |||
| */ | |||
| public String[] getCommandline() | |||
| throws TaskException | |||
| { | |||
| String[] result = new String[ size() ]; | |||
| int pos = 0; | |||
| String[] vmArgs = getActualVMCommand().getCommandline(); | |||
| // first argument is the java.exe path... | |||
| result[ pos++ ] = vmArgs[ 0 ]; | |||
| // -jar must be the first option in the command line. | |||
| if( executeJar ) | |||
| { | |||
| result[ pos++ ] = "-jar"; | |||
| } | |||
| // next follows the vm options | |||
| System.arraycopy( vmArgs, 1, result, pos, vmArgs.length - 1 ); | |||
| pos += vmArgs.length - 1; | |||
| // properties are part of the vm options... | |||
| if( m_sysProperties.size() > 0 ) | |||
| { | |||
| System.arraycopy( m_sysProperties.getJavaVariables(), 0, | |||
| result, pos, m_sysProperties.size() ); | |||
| pos += m_sysProperties.size(); | |||
| } | |||
| // classpath is a vm option too.. | |||
| if( m_classpath != null && ! m_classpath.isEmpty() ) | |||
| { | |||
| result[ pos++ ] = "-classpath"; | |||
| result[ pos++ ] = PathUtil.formatPath( m_classpath ); | |||
| } | |||
| // this is the classname to run as well as its arguments. | |||
| // in case of 'executeJar', the executable is a jar file. | |||
| System.arraycopy( m_javaCommand.getCommandline(), 0, | |||
| result, pos, m_javaCommand.size() ); | |||
| return result; | |||
| } | |||
| /** | |||
| * @return the pathname of the jar file to run via -jar option or <tt>null | |||
| * </tt> if there is no jar to run. | |||
| * @see #getClassname() | |||
| */ | |||
| public String getJar() | |||
| { | |||
| if( executeJar ) | |||
| { | |||
| return m_javaCommand.getExecutable(); | |||
| } | |||
| return null; | |||
| } | |||
| public Commandline getJavaCommand() | |||
| { | |||
| return m_javaCommand; | |||
| } | |||
| public SysProperties getSystemProperties() | |||
| { | |||
| return m_sysProperties; | |||
| } | |||
| public Commandline getVmCommand() | |||
| { | |||
| return getActualVMCommand(); | |||
| } | |||
| public void addSysproperty( EnvironmentVariable sysp ) | |||
| { | |||
| m_sysProperties.addVariable( sysp ); | |||
| } | |||
| public void addArgument( final String argument ) | |||
| { | |||
| m_javaCommand.addArgument( argument ); | |||
| } | |||
| public void addArgument( final Argument argument ) | |||
| { | |||
| m_javaCommand.addArgument( argument ); | |||
| } | |||
| public Path createClasspath() | |||
| { | |||
| if( m_classpath == null ) | |||
| { | |||
| m_classpath = new Path(); | |||
| } | |||
| return m_classpath; | |||
| } | |||
| public void addVmArgument( final String argument ) | |||
| { | |||
| m_vmCommand.addArgument( argument ); | |||
| } | |||
| public void addVmArgument( final Argument argument ) | |||
| { | |||
| m_vmCommand.addArgument( argument ); | |||
| } | |||
| public void restoreSystemProperties() | |||
| throws TaskException | |||
| { | |||
| m_sysProperties.restoreSystem(); | |||
| } | |||
| /** | |||
| * The size of the java command line. | |||
| * | |||
| * @return the total number of arguments in the java command line. | |||
| * @see #getCommandline() | |||
| */ | |||
| public int size() | |||
| throws TaskException | |||
| { | |||
| int size = getActualVMCommand().size() + m_javaCommand.size() + m_sysProperties.size(); | |||
| // classpath is "-classpath <classpath>" -> 2 args | |||
| if( m_classpath != null && ! m_classpath.isEmpty() ) | |||
| { | |||
| size += 2; | |||
| } | |||
| // jar execution requires an additional -jar option | |||
| if( executeJar ) | |||
| { | |||
| size++; | |||
| } | |||
| return size; | |||
| } | |||
| public String toString() | |||
| { | |||
| try | |||
| { | |||
| final String[] line = getCommandline(); | |||
| return StringUtil.join( line, " " ); | |||
| } | |||
| catch( TaskException e ) | |||
| { | |||
| return e.toString(); | |||
| } | |||
| } | |||
| private Commandline getActualVMCommand() | |||
| { | |||
| Commandline actualVMCommand = new Commandline(); | |||
| //(Commandline)vmCommand.clone(); | |||
| if( m_maxMemory != null ) | |||
| { | |||
| actualVMCommand.addArgument( "-Xmx" + m_maxMemory ); | |||
| } | |||
| return actualVMCommand; | |||
| } | |||
| } | |||
| @@ -21,7 +21,6 @@ public class EnvironmentData | |||
| protected final ArrayList m_variables = new ArrayList(); | |||
| public Properties getVariables() | |||
| throws TaskException | |||
| { | |||
| final Properties environment = new Properties(); | |||
| final int size = m_variables.size(); | |||
| @@ -37,4 +36,22 @@ public class EnvironmentData | |||
| { | |||
| m_variables.add( var ); | |||
| } | |||
| public void addVariable( String key, String value ) | |||
| { | |||
| final EnvironmentVariable var = new EnvironmentVariable(); | |||
| var.setKey( key ); | |||
| var.setValue( value ); | |||
| addVariable( var ); | |||
| } | |||
| public void addVariables( EnvironmentData properties ) | |||
| { | |||
| m_variables.addAll( properties.m_variables ); | |||
| } | |||
| public int size() | |||
| { | |||
| return m_variables.size(); | |||
| } | |||
| } | |||
| @@ -10,74 +10,74 @@ package org.apache.tools.todo.types; | |||
| import java.util.ArrayList; | |||
| import java.util.Iterator; | |||
| import java.util.Properties; | |||
| import org.apache.aut.nativelib.ExecException; | |||
| import java.util.Map; | |||
| import org.apache.myrmidon.api.TaskException; | |||
| import org.apache.tools.todo.types.EnvironmentData; | |||
| import org.apache.tools.todo.types.EnvironmentVariable; | |||
| /** | |||
| * Specialized EnvironmentData class for System properties | |||
| * A utility class for handling System properties | |||
| * | |||
| * @todo move this to AUT | |||
| */ | |||
| public class SysProperties | |||
| extends EnvironmentData | |||
| implements Cloneable | |||
| final public class SysProperties | |||
| { | |||
| private Properties m_system; | |||
| private static Properties m_system; | |||
| public void setSystem() | |||
| throws TaskException | |||
| private SysProperties() | |||
| { | |||
| try | |||
| { | |||
| Properties p = new Properties( m_system = System.getProperties() ); | |||
| } | |||
| for( Iterator e = m_variables.iterator(); e.hasNext(); ) | |||
| { | |||
| EnvironmentVariable v = (EnvironmentVariable)e.next(); | |||
| p.put( v.getKey(), v.getValue() ); | |||
| } | |||
| System.setProperties( p ); | |||
| } | |||
| catch( SecurityException e ) | |||
| { | |||
| throw new TaskException( "Cannot modify system properties", e ); | |||
| } | |||
| /** | |||
| * Sets system properties. The current set of system properties can be | |||
| * restored using {@link #restoreSystem}. | |||
| */ | |||
| public static void setSystem( final EnvironmentData properties ) | |||
| throws TaskException | |||
| { | |||
| setSystem( properties.getVariables() ); | |||
| } | |||
| /** | |||
| * @todo move this to AUT | |||
| * Sets system properties. The current set of system properties can be | |||
| * restored using {@link #restoreSystem}. | |||
| */ | |||
| public String[] getJavaVariables() | |||
| public synchronized static void setSystem( final Map properties ) | |||
| throws TaskException | |||
| { | |||
| String props[] = toNativeFormat( super.getVariables() ); | |||
| for( int i = 0; i < props.length; i++ ) | |||
| if( properties.size() == 0 ) | |||
| { | |||
| props[ i ] = "-D" + props[ i ]; | |||
| return; | |||
| } | |||
| if( m_system != null ) | |||
| { | |||
| throw new TaskException( "System properties have not been restored." ); | |||
| } | |||
| return props; | |||
| } | |||
| public Object clone() | |||
| { | |||
| final Properties sysProps; | |||
| try | |||
| { | |||
| SysProperties c = (SysProperties)super.clone(); | |||
| c.m_variables.addAll( (ArrayList)m_variables.clone() ); | |||
| return c; | |||
| sysProps = System.getProperties(); | |||
| Properties allProps = new Properties( sysProps ); | |||
| allProps.putAll( properties ); | |||
| System.setProperties( allProps ); | |||
| } | |||
| catch( CloneNotSupportedException e ) | |||
| catch( final SecurityException e ) | |||
| { | |||
| return null; | |||
| throw new TaskException( "Cannot modify system properties.", e ); | |||
| } | |||
| m_system = sysProps; | |||
| } | |||
| public void restoreSystem() | |||
| /** | |||
| * Restores the system properties to what they were before the last | |||
| * call to {@link #setSystem}. | |||
| */ | |||
| public static synchronized void restoreSystem() | |||
| throws TaskException | |||
| { | |||
| if( m_system == null ) | |||
| { | |||
| throw new TaskException( "Unbalanced nesting of SysProperties" ); | |||
| return; | |||
| } | |||
| try | |||
| @@ -85,29 +85,35 @@ public class SysProperties | |||
| System.setProperties( m_system ); | |||
| m_system = null; | |||
| } | |||
| catch( SecurityException e ) | |||
| catch( final SecurityException e ) | |||
| { | |||
| throw new TaskException( "Cannot modify system properties", e ); | |||
| throw new TaskException( "Cannot modify system properties.", e ); | |||
| } | |||
| } | |||
| public int size() | |||
| /** | |||
| * Converts a set of properties to their -D command-line equivalent. | |||
| */ | |||
| public static String[] getJavaVariables( final EnvironmentData environment ) | |||
| { | |||
| return m_variables.size(); | |||
| return getJavaVariables( environment.getVariables() ); | |||
| } | |||
| private String[] toNativeFormat( final Properties environment ) | |||
| /** | |||
| * Converts a set of properties to their -D command-line equivalent. | |||
| */ | |||
| public static String[] getJavaVariables( final Map environment ) | |||
| { | |||
| final ArrayList newEnvironment = new ArrayList(); | |||
| final ArrayList vars = new ArrayList(); | |||
| final Iterator keys = environment.keySet().iterator(); | |||
| while( keys.hasNext() ) | |||
| { | |||
| final String key = (String)keys.next(); | |||
| final String value = environment.getProperty( key ); | |||
| newEnvironment.add( key + '=' + value ); | |||
| final Object value = environment.get( key ); | |||
| vars.add( "-D" + key + '=' + value ); | |||
| } | |||
| return (String[])newEnvironment.toArray( new String[ newEnvironment.size() ] ); | |||
| return (String[])vars.toArray( new String[ vars.size() ] ); | |||
| } | |||
| } | |||