FileDocCategorySizeDatePackage
NetCommand.javaAPI DocApache Ant 1.7012515Wed Dec 13 06:16:24 GMT 2006org.apache.tools.ant.taskdefs.optional.dotnet

NetCommand

public class NetCommand extends Object
This is a helper class to spawn net commands out. In its initial form it contains no .net specifics, just contains all the command line/exe construction stuff. However, it may be handy in future to have a means of setting the path to point to the dotnet bin directory; in which case the shared code should go in here.
version
0.5

Fields Summary
private static final org.apache.tools.ant.util.FileUtils
FILE_UTILS
protected org.apache.tools.ant.Task
owner
owner project
protected org.apache.tools.ant.taskdefs.Execute
executable
executable
protected org.apache.tools.ant.types.Commandline
commandLine
what is the command line
protected String
title
title of the command
protected String
program
actual program to invoke
protected boolean
traceCommandLine
trace flag
protected boolean
failOnError
flag to control action on execution trouble
private File
directory
the directory to execute the command in. When null, the current directory is used.
private boolean
useResponseFile
flag to set to to use @file based command cache
private File
temporaryCommandFile
name of a temp file; may be null
private int
automaticResponseFileThreshold
internal threshold for auto-switch
Constructors Summary
public NetCommand(org.apache.tools.ant.Task owner, String title, String program)
constructor

param
title (for logging/errors)
param
owner owner task
param
program app we are to run


                                             

           
        this.owner = owner;
        this.title = title;
        this.program = program;
        commandLine = new Commandline();
        commandLine.setExecutable(program);
Methods Summary
public voidaddArgument(java.lang.String argument1, java.lang.String argument2)
concatenate two strings together and add them as a single argument, but only if argument2 is non-null and non-zero length

param
argument1 The first argument
param
argument2 The second argument

        if (argument2 != null && argument2.length() != 0) {
            commandLine.createArgument().setValue(argument1 + argument2);
        }
public voidaddArgument(java.lang.String argument)
add an argument to a command line; do nothing if the arg is null or empty string

param
argument The feature to be added to the Argument attribute

        if (argument != null && argument.length() != 0) {
            commandLine.createArgument().setValue(argument);
        }
public voidaddArguments(java.lang.String[] arguments)
add an argument to a command line; do nothing if the arg is null or empty string

param
arguments The features to be added to the Argument attribute

        if (arguments != null && arguments.length != 0) {
            for (int i = 0; i < arguments.length; i++) {
                addArgument(arguments[i]);
            }
        }
public intgetAutomaticResponseFileThreshold()
getter for threshold

return
0 for disabled, or a threshold for enabling response files

        return automaticResponseFileThreshold;
public booleangetFailFailOnError()
query fail on error flag

return
The failFailOnError value

        return failOnError;
public booleanisUseResponseFile()
getter

return
response file state

        return useResponseFile;
protected voidlogError(java.lang.String msg)
error text log

param
msg message to display as an error

        owner.getProject().log(msg, Project.MSG_ERR);
protected voidlogVerbose(java.lang.String msg)
verbose text log

param
msg string to add to log if verbose is defined for the build

        owner.getProject().log(msg, Project.MSG_VERBOSE);
protected voidprepareExecutor()
set up the command sequence..

        // default directory to the project's base directory
        if (owner == null) {
            throw new RuntimeException("no owner");
        }
        if (owner.getProject() == null) {
            throw new RuntimeException("Owner has no project");
        }
        File dir = owner.getProject().getBaseDir();
        if (directory != null) {
            dir = directory;
        }

        ExecuteStreamHandler handler = new LogStreamHandler(owner,
                Project.MSG_INFO, Project.MSG_WARN);
        executable = new Execute(handler, null);
        executable.setAntRun(owner.getProject());
        executable.setWorkingDirectory(dir);
public voidrunCommand()
Run the command using the given Execute instance.

exception
BuildException if something goes wrong and the failOnError flag is true

        prepareExecutor();
        int err = -1;
        // assume the worst
        try {
            if (traceCommandLine) {
                owner.log("In directory " + executable.getWorkingDirectory());
                owner.log(commandLine.describeCommand());
            } else {
                //in verbose mode we always log stuff
                logVerbose("In directory " + executable.getWorkingDirectory());
                logVerbose(commandLine.describeCommand());
            }
            setExecutableCommandLine();
            err = executable.execute();
            if (Execute.isFailure(err)) {
                if (failOnError) {
                    throw new BuildException(title + " returned: " + err, owner.getLocation());
                } else {
                    owner.log(title + "  Result: " + err, Project.MSG_ERR);
                }
            }
        } catch (IOException e) {
            throw new BuildException(title + " failed: " + e, e, owner.getLocation());
        } finally {
            if (temporaryCommandFile != null) {
                temporaryCommandFile.delete();
            }
        }
public intscanOneFileset(org.apache.tools.ant.DirectoryScanner scanner, java.util.Hashtable filesToBuild, long outputTimestamp)
scan through one fileset for files to include

param
scanner the directory scanner to use.
param
filesToBuild the map to place the files.
param
outputTimestamp timestamp to compare against
return
#of files out of date
todo
should FAT granularity be included here?

        int filesOutOfDate = 0;
        String[] dependencies = scanner.getIncludedFiles();
        File base = scanner.getBasedir();
        //add to the list
        for (int i = 0; i < dependencies.length; i++) {
            File targetFile = new File(base, dependencies[i]);
            if (filesToBuild.get(targetFile) == null) {
                filesToBuild.put(targetFile, targetFile);
                if (targetFile.lastModified() > outputTimestamp) {
                    filesOutOfDate++;
                    owner.log(targetFile.toString() + " is out of date",
                              Project.MSG_VERBOSE);
                } else {
                    owner.log(targetFile.toString(),
                              Project.MSG_VERBOSE);
                }
            }
        }
        return filesOutOfDate;
public voidsetAutomaticResponseFileThreshold(int automaticResponseFileThreshold)
set threshold for automatically using response files -use 0 for off

param
automaticResponseFileThreshold the threshold value to use.

        this.automaticResponseFileThreshold = automaticResponseFileThreshold;
public voidsetDirectory(java.io.File directory)
set the directory to run from, if the default is inadequate

param
directory the directory to use.

        this.directory = directory;
private voidsetExecutableCommandLine()
set the executable command line


        String[] commands = commandLine.getCommandline();
        //always trigger file mode if commands are big enough
        if (automaticResponseFileThreshold > 0
            && commands.length > automaticResponseFileThreshold) {
            useResponseFile = true;
        }
        if (!useResponseFile || commands.length <= 1) {
            //the simple action is to send the command line in as is
            executable.setCommandline(commands);
        } else {
            //but for big operations, we save all the params to a temp file
            //and set @tmpfile as the command -then we remember to delete the tempfile
            //afterwards
            FileOutputStream fos = null;

            temporaryCommandFile = FILE_UTILS.createTempFile("cmd", ".txt", null);
            owner.log("Using response file " + temporaryCommandFile, Project.MSG_VERBOSE);

            try {
                fos = new FileOutputStream(temporaryCommandFile);
                PrintWriter out = new PrintWriter(new BufferedOutputStream(fos));
                //start at 1 because element 0 is the executable name
                for (int i = 1; i < commands.length; ++i) {
                    out.println(commands[i]);
                }
                out.flush();
                out.close();
            } catch (IOException ex) {
                throw new BuildException("saving command stream to " + temporaryCommandFile, ex);
            }

            String[] newCommandLine = new String[2];
            newCommandLine[0] = commands[0];
            newCommandLine[1] = "@" + temporaryCommandFile.getAbsolutePath();
            logVerbose(Commandline.describeCommand(newCommandLine));
            executable.setCommandline(newCommandLine);
        }
public voidsetFailOnError(boolean b)
set fail on error flag

param
b fail flag -set to true to cause an exception to be raised if the return value != 0

        failOnError = b;
public voidsetTraceCommandLine(boolean b)
turn tracing on or off

param
b trace flag

        traceCommandLine = b;
public voidsetUseResponseFile(boolean useResponseFile)
set this to true to always use the response file

param
useResponseFile a boolean value.

        this.useResponseFile = useResponseFile;