FileDocCategorySizeDatePackage
AbstractCvsTask.javaAPI DocApache Ant 1.7023114Wed Dec 13 06:16:22 GMT 2006org.apache.tools.ant.taskdefs

AbstractCvsTask

public abstract class AbstractCvsTask extends org.apache.tools.ant.Task
original Cvs.java 1.20 NOTE: This implementation has been moved here from Cvs.java with the addition of some accessors for extensibility. Another task can extend this with some customized output processing.
since
Ant 1.5

Fields Summary
public static final int
DEFAULT_COMPRESSION_LEVEL
Default compression level to use, if compression is enabled via setCompression( true ).
private static final int
MAXIMUM_COMRESSION_LEVEL
private org.apache.tools.ant.types.Commandline
cmd
private Vector
vecCommandlines
list of Commandline children
private String
cvsRoot
the CVSROOT variable.
private String
cvsRsh
the CVS_RSH variable.
private String
cvsPackage
the package/module to check out.
private String
tag
the tag
private static final String
DEFAULT_COMMAND
the default command.
private String
command
the CVS command to execute.
private boolean
quiet
suppress information messages.
private boolean
reallyquiet
suppress all messages.
private int
compression
compression level to use.
private boolean
noexec
report only, don't change any files.
private int
port
CVS port
private File
passFile
CVS password file
private File
dest
the directory where the checked out files should be placed.
private boolean
append
whether or not to append stdout/stderr to existing files
private File
output
the file to direct standard output from the command.
private File
error
the file to direct standard error from the command.
private boolean
failOnError
If true it will stop the build if cvs exits with error. Default is false. (Iulian)
private ExecuteStreamHandler
executeStreamHandler
Create accessors for the following, to allow different handling of the output.
private OutputStream
outputStream
private OutputStream
errorStream
Constructors Summary
public AbstractCvsTask()
empty no-arg constructor


       
      
        super();
Methods Summary
public voidaddCommandArgument(java.lang.String arg)
This needs to be public to allow configuration of commands externally.

param
arg command argument

        this.addCommandArgument(cmd, arg);
public voidaddCommandArgument(org.apache.tools.ant.types.Commandline c, java.lang.String arg)
This method adds a command line argument to an external command. I do not understand what this method does in this class ??? particularly not why it is public ???? AntoineLL July 23d 2003

param
c command line to which one argument should be added
param
arg argument to add

        c.createArgument().setValue(arg);
public voidaddConfiguredCommandline(org.apache.tools.ant.types.Commandline c)
Adds direct command-line to execute.

param
c command line to execute

        this.addConfiguredCommandline(c, false);
public voidaddConfiguredCommandline(org.apache.tools.ant.types.Commandline c, boolean insertAtStart)
Configures and adds the given Commandline.

param
c commandline to insert
param
insertAtStart If true, c is inserted at the beginning of the vector of command lines

        if (c == null) {
            return;
        }
        this.configureCommandline(c);
        if (insertAtStart) {
            vecCommandlines.insertElementAt(c, 0);
        } else {
            vecCommandlines.addElement(c);
        }
protected voidconfigureCommandline(org.apache.tools.ant.types.Commandline c)
Configure a commandline element for things like cvsRoot, quiet, etc.

param
c the command line which will be configured if the commandline is initially null, the function is a noop otherwise the function append to the commandline arguments concerning
  • cvs package
  • compression
  • quiet or reallyquiet
  • cvsroot
  • noexec

        if (c == null) {
            return;
        }
        c.setExecutable("cvs");
        if (cvsPackage != null) {
            c.createArgument().setLine(cvsPackage);
        }
        if (this.compression > 0
            && this.compression <= MAXIMUM_COMRESSION_LEVEL) {
            c.createArgument(true).setValue("-z" + this.compression);
        }
        if (quiet && !reallyquiet) {
            c.createArgument(true).setValue("-q");
        }
        if (reallyquiet) {
            c.createArgument(true).setValue("-Q");
        }
        if (noexec) {
            c.createArgument(true).setValue("-n");
        }
        if (cvsRoot != null) {
            c.createArgument(true).setLine("-d" + cvsRoot);
        }
public voidexecute()
do the work

throws
BuildException if failonerror is set to true and the cvs command fails.


        String savedCommand = getCommand();

        if (this.getCommand() == null && vecCommandlines.size() == 0) {
            // re-implement legacy behaviour:
            this.setCommand(AbstractCvsTask.DEFAULT_COMMAND);
        }

        String c = this.getCommand();
        Commandline cloned = null;
        if (c != null) {
            cloned = (Commandline) cmd.clone();
            cloned.createArgument(true).setLine(c);
            this.addConfiguredCommandline(cloned, true);
        }

        try {
            for (int i = 0; i < vecCommandlines.size(); i++) {
                this.runCommand((Commandline) vecCommandlines.elementAt(i));
            }
        } finally {
            if (cloned != null) {
                removeCommandline(cloned);
            }
            setCommand(savedCommand);
            FileUtils.close(outputStream);
            FileUtils.close(errorStream);
        }
private java.lang.StringexecuteToString(Execute execute)


        StringBuffer stringBuffer =
            new StringBuffer(Commandline.describeCommand(execute
                                                         .getCommandline()));

        String newLine = StringUtils.LINE_SEP;
        String[] variableArray = execute.getEnvironment();

        if (variableArray != null) {
            stringBuffer.append(newLine);
            stringBuffer.append(newLine);
            stringBuffer.append("environment:");
            stringBuffer.append(newLine);
            for (int z = 0; z < variableArray.length; z++) {
                stringBuffer.append(newLine);
                stringBuffer.append("\t");
                stringBuffer.append(variableArray[z]);
            }
        }

        return stringBuffer.toString();
public java.lang.StringgetCommand()
accessor to a command line as string This should be deprecated AntoineLL July 23d 2003

return
command line as string

        return this.command;
public java.lang.StringgetCvsRoot()
access the CVSROOT variable

return
CVSROOT


        return this.cvsRoot;
public java.lang.StringgetCvsRsh()
access the CVS_RSH variable

return
the CVS_RSH variable


        return this.cvsRsh;
public java.io.FilegetDest()
get the file where the checked out files should be placed

return
directory where the checked out files should be placed


        return this.dest;
protected java.io.OutputStreamgetErrorStream()
access the stream to which the stderr from cvs should go if this stream has already been set, it will be returned if the stream has not yet been set, if the attribute error has been set, the output stream will go to the file denoted by the error attribute otherwise the stderr output will go to ant's logging system

return
output stream to which cvs' stderr should go to


        if (this.errorStream == null) {

            if (error != null) {

                try {
                    setErrorStream(new PrintStream(
                                       new BufferedOutputStream(
                                           new FileOutputStream(error.getPath(),
                                                                append))));
                } catch (IOException e) {
                    throw new BuildException(e, getLocation());
                }
            } else {
                setErrorStream(new LogOutputStream(this, Project.MSG_WARN));
            }
        }

        return this.errorStream;
protected ExecuteStreamHandlergetExecuteStreamHandler()
find the handler and instantiate it if it does not exist yet

return
handler for output and error streams


        if (this.executeStreamHandler == null) {
            setExecuteStreamHandler(new PumpStreamHandler(getOutputStream(),
                                                          getErrorStream()));
        }

        return this.executeStreamHandler;
protected java.io.OutputStreamgetOutputStream()
access the stream to which the stdout from cvs should go if this stream has already been set, it will be returned if the stream has not yet been set, if the attribute output has been set, the output stream will go to the output file otherwise the output will go to ant's logging system

return
output stream to which cvs' stdout should go to


        if (this.outputStream == null) {

            if (output != null) {
                try {
                    setOutputStream(new PrintStream(
                                        new BufferedOutputStream(
                                            new FileOutputStream(output
                                                                 .getPath(),
                                                                 append))));
                } catch (IOException e) {
                    throw new BuildException(e, getLocation());
                }
            } else {
                setOutputStream(new LogOutputStream(this, Project.MSG_INFO));
            }
        }

        return this.outputStream;
public java.lang.StringgetPackage()
access the package or module to operate upon

return
package/module


        return this.cvsPackage;
public java.io.FilegetPassFile()
find the password file

return
password file


        return this.passFile;
public intgetPort()
access the port of CVS

return
the port of CVS


        return this.port;
public java.lang.StringgetTag()
tag or branch

return
tag or branch
since
ant 1.6.1

        return tag;
protected voidremoveCommandline(org.apache.tools.ant.types.Commandline c)
remove a particular command from a vector of command lines

param
c command line which should be removed

        vecCommandlines.removeElement(c);
protected voidrunCommand(org.apache.tools.ant.types.Commandline toExecute)
Sets up the environment for toExecute and then runs it.

param
toExecute the command line to execute
throws
BuildException if failonError is set to true and the cvs command fails

        // XXX: we should use JCVS (www.ice.com/JCVS) instead of
        // command line execution so that we don't rely on having
        // native CVS stuff around (SM)

        // We can't do it ourselves as jCVS is GPLed, a third party task
        // outside of jakarta repositories would be possible though (SB).

        Environment env = new Environment();

        if (port > 0) {
            Environment.Variable var = new Environment.Variable();
            var.setKey("CVS_CLIENT_PORT");
            var.setValue(String.valueOf(port));
            env.addVariable(var);
        }

        /**
         * Need a better cross platform integration with <cvspass>, so
         * use the same filename.
         */
        if (passFile == null) {

            File defaultPassFile = new File(
                System.getProperty("cygwin.user.home",
                    System.getProperty("user.home"))
                + File.separatorChar + ".cvspass");

            if (defaultPassFile.exists()) {
                this.setPassfile(defaultPassFile);
            }
        }

        if (passFile != null) {
            if (passFile.isFile() && passFile.canRead()) {
                Environment.Variable var = new Environment.Variable();
                var.setKey("CVS_PASSFILE");
                var.setValue(String.valueOf(passFile));
                env.addVariable(var);
                log("Using cvs passfile: " + String.valueOf(passFile),
                    Project.MSG_VERBOSE);
            } else if (!passFile.canRead()) {
                log("cvs passfile: " + String.valueOf(passFile)
                    + " ignored as it is not readable",
                    Project.MSG_WARN);
            } else {
                log("cvs passfile: " + String.valueOf(passFile)
                    + " ignored as it is not a file",
                    Project.MSG_WARN);
            }
        }

        if (cvsRsh != null) {
            Environment.Variable var = new Environment.Variable();
            var.setKey("CVS_RSH");
            var.setValue(String.valueOf(cvsRsh));
            env.addVariable(var);
        }

        //
        // Just call the getExecuteStreamHandler() and let it handle
        //     the semantics of instantiation or retrieval.
        //
        Execute exe = new Execute(getExecuteStreamHandler(), null);

        exe.setAntRun(getProject());
        if (dest == null) {
            dest = getProject().getBaseDir();
        }

        if (!dest.exists()) {
            dest.mkdirs();
        }

        exe.setWorkingDirectory(dest);
        exe.setCommandline(toExecute.getCommandline());
        exe.setEnvironment(env.getVariables());

        try {
            String actualCommandLine = executeToString(exe);
            log(actualCommandLine, Project.MSG_VERBOSE);
            int retCode = exe.execute();
            log("retCode=" + retCode, Project.MSG_DEBUG);
            /*Throw an exception if cvs exited with error. (Iulian)*/
            if (failOnError && Execute.isFailure(retCode)) {
                throw new BuildException("cvs exited with error code "
                                         + retCode
                                         + StringUtils.LINE_SEP
                                         + "Command line was ["
                                         + actualCommandLine + "]",
                                         getLocation());
            }
        } catch (IOException e) {
            if (failOnError) {
                throw new BuildException(e, getLocation());
            }
            log("Caught exception: " + e.getMessage(), Project.MSG_WARN);
        } catch (BuildException e) {
            if (failOnError) {
                throw(e);
            }
            Throwable t = e.getException();
            if (t == null) {
                t = e;
            }
            log("Caught exception: " + t.getMessage(), Project.MSG_WARN);
        } catch (Exception e) {
            if (failOnError) {
                throw new BuildException(e, getLocation());
            }
            log("Caught exception: " + e.getMessage(), Project.MSG_WARN);
        }
public voidsetAppend(boolean value)
Whether to append output/error when redirecting to a file.

param
value true indicated you want to append

        this.append = value;
public voidsetCommand(java.lang.String c)
The CVS command to execute. This should be deprecated, it is better to use the Commandline class ? AntoineLL July 23d 2003

param
c a command as string

        this.command = c;
public voidsetCompression(boolean usecomp)
If true, this is the same as compressionlevel="3".

param
usecomp If true, turns on compression using default level, AbstractCvsTask.DEFAULT_COMPRESSION_LEVEL.

        setCompressionLevel(usecomp
            ? AbstractCvsTask.DEFAULT_COMPRESSION_LEVEL : 0);
public voidsetCompressionLevel(int level)
If set to a value 1-9 it adds -zN to the cvs command line, else it disables compression.

param
level compression level 1 to 9

        this.compression = level;
public voidsetCvsRoot(java.lang.String root)
The CVSROOT variable.

param
root the CVSROOT variable


        // Check if not real cvsroot => set it to null
        if (root != null) {
            if (root.trim().equals("")) {
                root = null;
            }
        }

        this.cvsRoot = root;
public voidsetCvsRsh(java.lang.String rsh)
The CVS_RSH variable.

param
rsh the CVS_RSH variable

        // Check if not real cvsrsh => set it to null
        if (rsh != null) {
            if (rsh.trim().equals("")) {
                rsh = null;
            }
        }

        this.cvsRsh = rsh;
public voidsetDate(java.lang.String p)
Use the most recent revision no later than the given date.

param
p a date as string in a format that the CVS executable can understand see man cvs

        if (p != null && p.trim().length() > 0) {
            addCommandArgument("-D");
            addCommandArgument(p);
        }
public voidsetDest(java.io.File dest)
The directory where the checked out files should be placed.

Note that this is different from CVS's -d command line switch as Ant will never shorten pathnames to avoid empty directories.

param
dest directory where the checked out files should be placed

        this.dest = dest;
public voidsetError(java.io.File error)
The file to direct standard error from the command.

param
error a file to which stderr should go

        this.error = error;
protected voidsetErrorStream(java.io.OutputStream errorStream)
sets a stream to which the stderr from the cvs exe should go

param
errorStream an output stream willing to process stderr


        this.errorStream = errorStream;
public voidsetExecuteStreamHandler(ExecuteStreamHandler handler)
sets the handler

param
handler a handler able of processing the output and error streams from the cvs exe

        this.executeStreamHandler = handler;
public voidsetFailOnError(boolean failOnError)
Stop the build process if the command exits with a return code other than 0. Defaults to false.

param
failOnError stop the build process if the command exits with a return code other than 0

        this.failOnError = failOnError;
public voidsetNoexec(boolean ne)
If true, report only and don't change any files.

param
ne if true, report only and do not change any files.

        noexec = ne;
public voidsetOutput(java.io.File output)
The file to direct standard output from the command.

param
output a file to which stdout should go

        this.output = output;
protected voidsetOutputStream(java.io.OutputStream outputStream)
sets a stream to which the output from the cvs executable should be sent

param
outputStream stream to which the stdout from cvs should go


        this.outputStream = outputStream;
public voidsetPackage(java.lang.String p)
The package/module to operate upon.

param
p package or module to operate upon

        this.cvsPackage = p;
public voidsetPassfile(java.io.File passFile)
Password file to read passwords from.

param
passFile password file to read passwords from

        this.passFile = passFile;
public voidsetPort(int port)
Port used by CVS to communicate with the server.

param
port port of CVS

        this.port = port;
public voidsetQuiet(boolean q)
If true, suppress informational messages.

param
q if true, suppress informational messages

        quiet = q;
public voidsetReallyquiet(boolean q)
If true, suppress all messages.

param
q if true, suppress all messages
since
Ant 1.6

        reallyquiet = q;
public voidsetTag(java.lang.String p)
The tag of the package/module to operate upon.

param
p tag

        // Check if not real tag => set it to null
        if (p != null && p.trim().length() > 0) {
            tag = p;
            addCommandArgument("-r" + p);
        }