/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Ant", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.tools.ant.taskdefs;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.Vector;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.types.Commandline;
import org.apache.tools.ant.types.Environment;
import org.apache.tools.ant.util.StringUtils;
/**
* 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.
*
* @author costin@dnt.ro
* @author stefano@apache.org
* @author Wolfgang Werner
* <a href="mailto:wwerner@picturesafe.de">wwerner@picturesafe.de</a>
* @author Kevin Ross
* <a href="mailto:kevin.ross@bredex.com">kevin.ross@bredex.com</a>
*
* @since Ant 1.5
*/
public abstract class AbstractCvsTask extends Task {
/**
* Default compression level to use, if compression is enabled via
* setCompression( true ).
*/
public static final int DEFAULT_COMPRESSION_LEVEL = 3;
private Commandline cmd = new Commandline();
/** list of Commandline children */
private Vector vecCommandlines = new Vector();
/**
* the CVSROOT variable.
*/
private String cvsRoot;
/**
* the CVS_RSH variable.
*/
private String cvsRsh;
/**
* the package/module to check out.
*/
private String cvsPackage;
/**
* the default command.
*/
private static final String default_command = "checkout";
/**
* the CVS command to execute.
*/
private String command = null;
/**
* suppress information messages.
*/
private boolean quiet = false;
/**
* compression level to use.
*/
private int compression = 0;
/**
* report only, don't change any files.
*/
private boolean noexec = false;
/**
* CVS port
*/
private int port = 0;
/**
* CVS password file
*/
private File passFile = null;
/**
* the directory where the checked out files should be placed.
*/
private File dest;
/** whether or not to append stdout/stderr to existing files */
private boolean append = false;
/**
* the file to direct standard output from the command.
*/
private File output;
/**
* the file to direct standard error from the command.
*/
private File error;
/**
* If true it will stop the build if cvs exits with error.
* Default is false. (Iulian)
*/
private boolean failOnError = false;
/**
* Create accessors for the following, to allow different handling of
* the output.
*/
private ExecuteStreamHandler executeStreamHandler;
private OutputStream outputStream;
private OutputStream errorStream;
/** empty no-arg constructor*/
public AbstractCvsTask() {
super();
}
public void setExecuteStreamHandler(ExecuteStreamHandler handler) {
this.executeStreamHandler = handler;
}
protected ExecuteStreamHandler getExecuteStreamHandler() {
if (this.executeStreamHandler == null) {
setExecuteStreamHandler(new PumpStreamHandler(getOutputStream(),
getErrorStream()));
}
return this.executeStreamHandler;
}
protected void setOutputStream(OutputStream outputStream) {
this.outputStream = outputStream;
}
protected OutputStream getOutputStream() {
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, location);
}
} else {
setOutputStream(new LogOutputStream(this, Project.MSG_INFO));
}
}
return this.outputStream;
}
protected void setErrorStream(OutputStream errorStream) {
this.errorStream = errorStream;
}
protected OutputStream getErrorStream() {
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, location);
}
} else {
setErrorStream(new LogOutputStream(this, Project.MSG_WARN));
}
}
return this.errorStream;
}
/**
* Sets up the environment for toExecute and then runs it.
* @throws BuildException
*/
protected void runCommand(Commandline toExecute) throws BuildException {
// 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) {
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_INFO);
}
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(project);
if (dest == null) {
dest = project.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 && retCode != 0) {
throw new BuildException("cvs exited with error code "
+ retCode
+ StringUtils.LINE_SEP
+ "Command line was ["
+ actualCommandLine + "]", location);
}
} catch (IOException e) {
if (failOnError) {
throw new BuildException(e, location);
} else {
log("Caught exception: " + e.getMessage(), Project.MSG_WARN);
}
} catch (BuildException e) {
if (failOnError) {
throw(e);
} else {
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, location);
} else {
log("Caught exception: " + e.getMessage(), Project.MSG_WARN);
}
} finally {
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {}
}
if (errorStream != null) {
try {
errorStream.close();
} catch (IOException e) {}
}
}
}
public void execute() throws BuildException {
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);
}
}
private String executeToString(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();
}
/**
* The CVSROOT variable.
*
* @param root
*/
public void setCvsRoot(String root) {
// Check if not real cvsroot => set it to null
if (root != null) {
if (root.trim().equals("")) {
root = null;
}
}
this.cvsRoot = root;
}
public String getCvsRoot(){
return this.cvsRoot;
}
/**
* The CVS_RSH variable.
*
* @param rsh
*/
public void setCvsRsh(String rsh) {
// Check if not real cvsrsh => set it to null
if (rsh != null) {
if (rsh.trim().equals("")) {
rsh = null;
}
}
this.cvsRsh = rsh;
}
public String getCvsRsh(){
return this.cvsRsh;
}
/**
* Port used by CVS to communicate with the server.
*
* @param port
*/
public void setPort(int port){
this.port = port;
}
public int getPort(){
return this.port;
}
/**
* Password file to read passwords from.
*
* @param passFile
*/
public void setPassfile(File passFile){
this.passFile = passFile;
}
public File getPassFile(){
return this.passFile;
}
/**
* The directory where the checked out files should be placed.
*
* @param dest
*/
public void setDest(File dest) {
this.dest = dest;
}
public File getDest(){
return this.dest;
}
/**
* The package/module to operate upon.
*
* @param p
*/
public void setPackage(String p) {
this.cvsPackage = p;
}
public String getPackage(){
return this.cvsPackage;
}
/**
* The tag of the package/module to operate upon.
* @param p
*/
public void setTag(String p) {
// Check if not real tag => set it to null
if (p != null && p.trim().length() > 0) {
addCommandArgument("-r");
addCommandArgument(p);
}
}
/**
* This needs to be public to allow configuration
* of commands externally.
*/
public void addCommandArgument(String arg){
this.addCommandArgument(cmd, arg);
}
public void addCommandArgument(Commandline c, String arg){
c.createArgument().setValue(arg);
}
/**
* Use the most recent revision no later than the given date.
* @param p
*/
public void setDate(String p) {
if (p != null && p.trim().length() > 0) {
addCommandArgument("-D");
addCommandArgument(p);
}
}
/**
* The CVS command to execute.
* @param c
*/
public void setCommand(String c) {
this.command = c;
}
public String getCommand() {
return this.command;
}
/**
* If true, suppress informational messages.
* @param q
*/
public void setQuiet(boolean q) {
quiet = q;
}
/**
* If true, report only and don't change any files.
*
* @param ne
*/
public void setNoexec(boolean ne) {
noexec = ne;
}
/**
* The file to direct standard output from the command.
* @param output
*/
public void setOutput(File output) {
this.output = output;
}
/**
* The file to direct standard error from the command.
*
* @param error
*/
public void setError(File error) {
this.error = error;
}
/**
* Whether to append output/error when redirecting to a file.
* @param value
*/
public void setAppend(boolean value){
this.append = value;
}
/**
* Stop the build process if the command exits with
* a return code other than 0.
* Defaults to false.
* @param failOnError
*/
public void setFailOnError(boolean failOnError) {
this.failOnError = failOnError;
}
/**
* Configure a commandline element for things like cvsRoot, quiet, etc.
*/
protected void configureCommandline(Commandline c) {
if (c == null) {
return;
}
c.setExecutable("cvs");
if (cvsPackage != null) {
c.createArgument().setLine(cvsPackage);
}
if (this.compression > 0 && this.compression < 10) {
c.createArgument(true).setValue("-z" + this.compression);
}
if (quiet) {
c.createArgument(true).setValue("-q");
}
if (noexec) {
c.createArgument(true).setValue("-n");
}
if (cvsRoot != null) {
c.createArgument(true).setLine("-d" + cvsRoot);
}
}
protected void removeCommandline(Commandline c) {
vecCommandlines.removeElement(c);
}
/**
* Adds direct command-line to execute.
* @param c
*/
public void addConfiguredCommandline(Commandline c) {
this.addConfiguredCommandline(c, false);
}
/**
* Configures and adds the given Commandline.
* @param insertAtStart If true, c is
*/
public void addConfiguredCommandline(Commandline c,
boolean insertAtStart) {
if (c == null) {
return;
}
this.configureCommandline(c);
if (insertAtStart) {
vecCommandlines.insertElementAt(c, 0);
} else {
vecCommandlines.addElement(c);
}
}
/**
* If set to a value 1-9 it adds -zN to the cvs command line, else
* it disables compression.
*/
public void setCompressionLevel(int level) {
this.compression = level;
}
/**
* If true, this is the same as compressionlevel="3".
*
* @param usecomp If true, turns on compression using default
* level, AbstractCvsTask.DEFAULT_COMPRESSION_LEVEL.
*/
public void setCompression(boolean usecomp) {
setCompressionLevel(usecomp ?
AbstractCvsTask.DEFAULT_COMPRESSION_LEVEL : 0);
}
}