These libraries are only used by the CVS support.

git-svn-id: https://hudson.dev.java.net/svn/hudson/trunk/hudson/main@24921 71c3de6d-444a-0410-be80-ed276b4c234a
This commit is contained in:
kohsuke committed 2009-12-24 19:45:04 +00:00
1 parent e101203980
commit bb8bf43ccf
10 files changed
-2250

No files matched your search

@@ -1,862 +0,0 @@
/*
* Copyright 2002-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;
import java.util.ArrayList;
import java.util.List;
import java.util.Vector;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.taskdefs.ExecuteStreamHandler;
import org.apache.tools.ant.taskdefs.PumpStreamHandler;
import org.apache.tools.ant.taskdefs.LogOutputStream;
import org.apache.tools.ant.taskdefs.Execute;
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.
*
* @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 static final int MAXIMUM_COMRESSION_LEVEL = 9;
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 tag
*/
private String tag;
/**
* 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;
/**
* suppress all messages.
*/
private boolean reallyquiet = 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 OutputStream outputStream;
private OutputStream errorStream;
private String cvsExe = "cvs";
/** empty no-arg constructor*/
public AbstractCvsTask() {
super();
}
public void setCvsExe(String cvsExe) {
this.cvsExe = cvsExe;
}
/**
* find the handler and instantiate it if it does not exist yet
* @return handler for output and error streams
*/
protected ExecuteStreamHandler getExecuteStreamHandler(InputStream input) {
return new PumpStreamHandler(getOutputStream(), getErrorStream(), input);
}
/**
* 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
*/
protected void setOutputStream(OutputStream outputStream) {
this.outputStream = outputStream;
}
/**
* 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
*/
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, getLocation());
}
} else {
setOutputStream(new LogOutputStream(this, Project.MSG_INFO));
}
}
return this.outputStream;
}
/**
* sets a stream to which the stderr from the cvs exe should go
* @param errorStream an output stream willing to process stderr
*/
protected void setErrorStream(OutputStream errorStream) {
this.errorStream = errorStream;
}
/**
* 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
*/
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, getLocation());
}
} else {
setErrorStream(new LogOutputStream(this, Project.MSG_WARN));
}
}
return this.errorStream;
}
/**
* 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
*/
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) {
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_INFO);
} 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.
//
String[] argv = toExecute.getCommandline();
InputStream input = null;
String inputText = null;
if (new File("/usr/bin/xargs").isFile()) {
// Hudson workaround #864. Check for very long command lines and use xargs whenever possible.
int sz = 0;
for (String arg : argv) {
sz += arg.length() + /*NUL*/1;
}
if (sz > 125000) {
// We are in the danger zone for Linux, which imposes a 128Kb kernel buffer max by default.
// (Need to leave some room open for ENVP.)
ByteArrayOutputStream baos = null;
List<String> _argv = new ArrayList<String>();
_argv.add("/usr/bin/xargs");
boolean prefix = true;
LOAD: for (String s : argv) {
if (s.equals("--")) {
// See ChangeLogTask.execute. xargs will try to split up long input into >1 command.
prefix = false;
baos = new ByteArrayOutputStream();
} else if (prefix) {
_argv.add(s);
} else {
for (byte b : s.getBytes()) {
if (b < 0) {
// XXX we cannot handle non-ASCII chars here, probably. Punt.
baos = null;
break LOAD;
}
// GNU xargs accepts -0, which would be nice, but this is unfortunately not universal.
// The safest approach is to backslash every char, then use \n for separator.
baos.write('\\');
baos.write(b);
}
baos.write('\n');
}
}
if (baos != null) {
Logger.getLogger(AbstractCvsTask.class.getName()).log(Level.INFO, "Using xargs to run very long command line ({0} bytes)", sz);
input = new ByteArrayInputStream(baos.toByteArray());
inputText = baos.toString();
argv = _argv.toArray(new String[_argv.size()]);
}
}
}
Execute exe = new Execute(getExecuteStreamHandler(input), null);
exe.setAntRun(getProject());
if (dest == null) {
dest = getProject().getBaseDir();
}
if (!dest.exists()) {
dest.mkdirs();
}
exe.setWorkingDirectory(dest);
exe.setCommandline(argv);
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 + "] in " + dest +
"\nInput text:\nSTART==>" + inputText + "<==END", getLocation());
}
} catch (IOException e) {
if (failOnError) {
throw new BuildException(e, getLocation());
} 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, getLocation());
} else {
log("Caught exception: " + e.getMessage(), Project.MSG_WARN);
}
} finally {
if (outputStream != null) {
try {
outputStream.close();
} catch (IOException e) {
//ignore
}
}
if (errorStream != null) {
try {
errorStream.close();
} catch (IOException e) {
//ignore
}
}
}
}
/**
* do the work
* @throws BuildException if failonerror is set to true and the cvs command fails.
*/
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 the CVSROOT variable
*/
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;
}
/**
* access the CVSROOT variable
* @return CVSROOT
*/
public String getCvsRoot() {
return this.cvsRoot;
}
/**
* The CVS_RSH variable.
*
* @param rsh the CVS_RSH variable
*/
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;
}
/**
* access the CVS_RSH variable
* @return the CVS_RSH variable
*/
public String getCvsRsh() {
return this.cvsRsh;
}
/**
* Port used by CVS to communicate with the server.
*
* @param port port of CVS
*/
public void setPort(int port) {
this.port = port;
}
/**
* access the port of CVS
* @return the port of CVS
*/
public int getPort() {
return this.port;
}
/**
* Password file to read passwords from.
*
* @param passFile password file to read passwords from
*/
public void setPassfile(File passFile) {
this.passFile = passFile;
}
/**
* find the password file
* @return password file
*/
public File getPassFile() {
return this.passFile;
}
/**
* The directory where the checked out files should be placed.
*
* <p>Note that this is different from CVS's -d command line
* switch as Ant will never shorten pathnames to avoid empty
* directories.</p>
*
* @param dest directory where the checked out files should be placed
*/
public void setDest(File dest) {
this.dest = dest;
}
/**
* get the file where the checked out files should be placed
*
* @return directory where the checked out files should be placed
*/
public File getDest() {
return this.dest;
}
/**
* The package/module to operate upon.
*
* @param p package or module to operate upon
*/
public void setPackage(String... p) {
this.cvsPackage = p;
}
/**
* access the package or module to operate upon
*
* @return package/module
*/
public String[] getPackage() {
return this.cvsPackage;
}
/**
* tag or branch
* @return tag or branch
* @since ant 1.6.1
*/
public String getTag() {
return tag;
}
/**
* The tag of the package/module to operate upon.
* @param p tag
*/
public void setTag(String p) {
// Check if not real tag => set it to null
if (p != null && p.trim().length() > 0) {
tag = p;
addCommandArgument("-r" + p);
}
}
/**
* This needs to be public to allow configuration
* of commands externally.
* @param arg command argument
*/
public void addCommandArgument(String arg) {
this.addCommandArgument(cmd, 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
*/
public void addCommandArgument(Commandline c, String arg) {
c.createArgument().setValue(arg);
}
/**
* 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
*/
public void setDate(String p) {
if (p != null && p.trim().length() > 0) {
addCommandArgument("-D");
addCommandArgument(p);
}
}
/**
* 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
*/
public void setCommand(String c) {
this.command = c;
}
/**
* accessor to a command line as string
*
* This should be deprecated
* AntoineLL July 23d 2003
*
* @return command line as string
*/
public String getCommand() {
return this.command;
}
/**
* If true, suppress informational messages.
* @param q if true, suppress informational messages
*/
public void setQuiet(boolean q) {
quiet = q;
}
/**
* If true, suppress all messages.
* @param q if true, suppress all messages
* @since Ant 1.6
*/
public void setReallyquiet(boolean q) {
reallyquiet = q;
}
/**
* If true, report only and don't change any files.
*
* @param ne if true, report only and do not change any files.
*/
public void setNoexec(boolean ne) {
noexec = ne;
}
/**
* The file to direct standard output from the command.
* @param output a file to which stdout should go
*/
public void setOutput(File output) {
this.output = output;
}
/**
* The file to direct standard error from the command.
*
* @param error a file to which stderr should go
*/
public void setError(File error) {
this.error = error;
}
/**
* Whether to append output/error when redirecting to a file.
* @param value true indicated you want to append
*/
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 stop the build process if the command exits with
* a return code other than 0
*/
public void setFailOnError(boolean failOnError) {
this.failOnError = failOnError;
}
/**
* 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
* <ul>
* <li>
* cvs package
* </li>
* <li>
* compression
* </li>
* <li>
* quiet or reallyquiet
* </li>
* <li>cvsroot</li>
* <li>noexec</li>
* </ul>
*/
protected void configureCommandline(Commandline c) {
if (c == null) {
return;
}
c.setExecutable(cvsExe);
if (cvsPackage != null) {
for (String s : cvsPackage)
c.createArgument().setValue(s);
}
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);
}
}
/**
* remove a particular command from a vector of command lines
* @param c command line which should be removed
*/
protected void removeCommandline(Commandline c) {
vecCommandlines.removeElement(c);
}
/**
* Adds direct command-line to execute.
* @param c command line to execute
*/
public void addConfiguredCommandline(Commandline c) {
this.addConfiguredCommandline(c, false);
}
/**
* 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
*/
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.
* @param level compression level 1 to 9
*/
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);
}
}
@@ -1,87 +0,0 @@
/*
* Copyright 2002,2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
import java.util.Date;
import java.util.Vector;
/**
* CVS Entry.
*
* @version $Revision$ $Date$
*/
class CVSEntry {
private Date m_date;
private String m_author;
private final String m_comment;
private final Vector<RCSFile> m_files = new Vector<RCSFile>();
public CVSEntry(Date date, String author, String comment) {
m_date = date;
m_author = author;
m_comment = comment;
}
public void addFile(String file, String fullName, String revision, String previousRevision, String branch, boolean dead) {
m_files.addElement(new RCSFile(file, fullName, revision, previousRevision, branch, dead));
}
// maybe null, in case of error
Date getDate() {
return m_date;
}
void setAuthor(final String author) {
m_author = author;
}
String getAuthor() {
return m_author;
}
String getComment() {
return m_comment;
}
Vector getFiles() {
return m_files;
}
/**
* Checks if any of the entries include a change to a branch.
*
* @param branch
* can be null to indicate the trunk.
*/
public boolean containsBranch(String branch) {
for (RCSFile file : m_files) {
String b = file.getBranch();
if(b==null && branch==null)
return true;
if(b==null || branch==null)
continue;
if(b.equals(branch))
return true;
}
return false;
}
public String toString() {
return '['+getAuthor() + "," + getDate() + "," + getFiles() + ","
+ getComment()+']';
}
}
@@ -1,380 +0,0 @@
/*
* Copyright 2002-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
// patched to work around http://issues.apache.org/bugzilla/show_bug.cgi?id=38583
import org.apache.tools.ant.Project;
import org.apache.commons.io.FileUtils;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Map;
import java.util.Map.Entry;
import java.util.TimeZone;
import java.util.logging.Logger;
import java.util.logging.Level;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.io.File;
import java.io.IOException;
/**
* A class used to parse the output of the CVS log command.
*
* @version $Revision$ $Date$
*/
class ChangeLogParser {
//private static final int GET_ENTRY = 0;
private static final int GET_FILE = 1;
private static final int GET_DATE = 2;
private static final int GET_COMMENT = 3;
private static final int GET_REVISION = 4;
private static final int GET_PREVIOUS_REV = 5;
private static final int GET_SYMBOLIC_NAMES = 6;
/**
* input format for dates read in from cvs log.
*
* Some users reported that they see different formats,
* so this is extended from original Ant version to cover different formats.
*
* <p>
* KK: {@link SimpleDateFormat} is not thread safe, so make it per-instance.
*/
private final SimpleDateFormat[] c_inputDate
= new SimpleDateFormat[]{
new SimpleDateFormat("yyyy/MM/dd HH:mm:ss Z"),
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss Z"),
new SimpleDateFormat("yyyy/MM/dd HH:mm:ss"),
new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"),
};
{
TimeZone utc = TimeZone.getTimeZone("UTC");
for (SimpleDateFormat df : c_inputDate) {
df.setTimeZone(utc);
}
}
//The following is data used while processing stdout of CVS command
private String m_file;
private String m_fullName;
private String m_date;
private String m_author;
private String m_comment;
private String m_revision;
private String m_previousRevision;
/**
* All branches available on the current file.
* Keyed by branch revision prefix (like "1.2.3." if files in the branch have revision numbers like
* "1.2.3.4") and the value is the branch name.
*/
private final Map<String,String> branches = new HashMap<String,String>();
/**
* True if the log record indicates deletion;
*/
private boolean m_dead;
private int m_status = GET_FILE;
/** rcs entries */
private final Hashtable<String,CVSEntry> m_entries = new Hashtable<String,CVSEntry>();
private final ChangeLogTask owner;
public ChangeLogParser(ChangeLogTask owner) {
this.owner = owner;
}
/**
* Get a list of rcs entries as an array.
*
* @return a list of rcs entries as an array
*/
CVSEntry[] getEntrySetAsArray() {
final CVSEntry[] array = new CVSEntry[ m_entries.size() ];
Enumeration e = m_entries.elements();
int i = 0;
while (e.hasMoreElements()) {
array[i++] = (CVSEntry) e.nextElement();
}
return array;
}
private boolean dead = false;
private String previousLine = null;
/**
* Receive notification about the process writing
* to standard output.
*/
public void stdout(final String line) {
if(dead)
return;
try {
switch(m_status) {
case GET_FILE:
// make sure attributes are reset when
// working on a 'new' file.
reset();
processFile(line);
break;
case GET_SYMBOLIC_NAMES:
processSymbolicName(line);
break;
case GET_REVISION:
processRevision(line);
break;
case GET_DATE:
processDate(line);
break;
case GET_COMMENT:
processComment(line);
break;
case GET_PREVIOUS_REV:
processGetPreviousRevision(line);
break;
}
} catch (Exception e) {
// we don't know how to handle the input any more. don't accept any more input
dead = true;
}
}
/**
* Process a line while in "GET_COMMENT" state.
*
* @param line the line
*/
private void processComment(final String line) {
final String lineSeparator = System.getProperty("line.separator");
if (line.startsWith("======")) {
//We have ended changelog for that particular file
//so we can save it
final int end
= m_comment.length() - lineSeparator.length(); //was -1
m_comment = m_comment.substring(0, end);
saveEntry();
m_status = GET_FILE;
} else if (null != previousLine && previousLine.startsWith("----------------------------")) {
if (line.startsWith("revision")) {
final int end
= m_comment.length() - lineSeparator.length(); //was -1
m_comment = m_comment.substring(0, end);
m_status = GET_PREVIOUS_REV;
processGetPreviousRevision(line);
} else {
m_comment += previousLine + lineSeparator + line + lineSeparator;
}
previousLine = null;
} else if (line.startsWith("----------------------------")) {
if (null != previousLine) {
m_comment += previousLine + lineSeparator;
}
previousLine = line;
} else {
m_comment += line + lineSeparator;
}
}
/**
* Process a line while in "GET_FILE" state.
*
* @param line the line
*/
private void processFile(final String line) {
if (line.startsWith("Working file:")) {
m_file = line.substring(14, line.length());
File repo = new File(new File(owner.getDir(), m_file).getParentFile(), "CVS/Repository");
try {
String module = FileUtils.readFileToString(repo, null);// not sure what encoding CVS uses.
String simpleName = m_file.substring(m_file.lastIndexOf('/')+1);
m_fullName = '/'+module.trim()+'/'+simpleName;
} catch (IOException e) {
// failed to read
LOGGER.log(Level.WARNING, "Failed to read CVS/Repository at "+repo,e);
m_fullName = null;
}
m_status = GET_SYMBOLIC_NAMES;
}
}
/**
* Obtains the revision name list
*/
private void processSymbolicName(String line) {
if (line.startsWith("\t")) {
line = line.trim();
int idx = line.lastIndexOf(':');
if(idx<0) {
// ???
return;
}
String symbol = line.substring(0,idx);
Matcher m = DOT_PATTERN.matcher(line.substring(idx + 2));
if(!m.matches())
return; // not a branch name
branches.put(m.group(1)+m.group(3)+'.',symbol);
} else
if (line.startsWith("keyword substitution:")) {
m_status = GET_REVISION;
}
}
private static final Pattern DOT_PATTERN = Pattern.compile("(([0-9]+\\.)+)0\\.([0-9]+)");
/**
* Process a line while in "REVISION" state.
*
* @param line the line
*/
private void processRevision(final String line) {
if (line.startsWith("revision")) {
m_revision = line.substring(9);
m_status = GET_DATE;
} else if (line.startsWith("======")) {
//There was no revisions in this changelog
//entry so lets move unto next file
m_status = GET_FILE;
}
}
/**
* Process a line while in "DATE" state.
*
* @param line the line
*/
private void processDate(final String line) {
if (line.startsWith("date:")) {
int idx = line.indexOf(";");
m_date = line.substring(6, idx);
String lineData = line.substring(idx + 1);
m_author = lineData.substring(10, lineData.indexOf(";"));
m_status = GET_COMMENT;
m_dead = lineData.indexOf("state: dead;")!=-1;
//Reset comment to empty here as we can accumulate multiple lines
//in the processComment method
m_comment = "";
}
}
/**
* Process a line while in "GET_PREVIOUS_REVISION" state.
*
* @param line the line
*/
private void processGetPreviousRevision(final String line) {
if (!line.startsWith("revision")) {
throw new IllegalStateException("Unexpected line from CVS: "
+ line);
}
m_previousRevision = line.substring(9);
saveEntry();
m_revision = m_previousRevision;
m_status = GET_DATE;
}
/**
* Utility method that saves the current entry.
*/
private void saveEntry() {
final String entryKey = m_date + m_author + m_comment;
CVSEntry entry;
if (!m_entries.containsKey(entryKey)) {
entry = new CVSEntry(parseDate(m_date), m_author, m_comment);
m_entries.put(entryKey, entry);
} else {
entry = m_entries.get(entryKey);
}
String branch = findBranch(m_revision);
owner.log("Recorded a change: "+m_date+','+m_author+','+m_revision+"(branch="+branch+"),"+m_comment,Project.MSG_VERBOSE);
entry.addFile(m_file, m_fullName, m_revision, m_previousRevision, branch, m_dead);
}
/**
* Finds the branch name that matches the revision, or null if not found.
*/
private String findBranch(String revision) {
if(revision==null) return null; // defensive check
for (Entry<String,String> e : branches.entrySet()) {
if(revision.startsWith(e.getKey()) && revision.substring(e.getKey().length()).indexOf('.')==-1)
return e.getValue();
}
return null;
}
/**
* Parse date out from expected format.
*
* @param date the string holding dat
* @return the date object or null if unknown date format
*/
private Date parseDate(String date) {
for (SimpleDateFormat df : c_inputDate) {
try {
return df.parse(date);
} catch (ParseException e) {
// try next if one fails
}
}
// nothing worked
owner.log("Failed to parse "+date+"\n", Project.MSG_ERR);
//final String message = REZ.getString( "changelog.bat-date.error", date );
//getContext().error( message );
return null;
}
/**
* reset all internal attributes except status.
*/
private void reset() {
m_file = null;
m_fullName = null;
m_date = null;
m_author = null;
m_comment = null;
m_revision = null;
m_previousRevision = null;
m_dead = false;
branches.clear();
}
private static final Logger LOGGER = Logger.getLogger(ChangeLogParser.class.getName());
}
@@ -1,501 +0,0 @@
/*
* Copyright 2002-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
import hudson.util.ForkOutputStream;
import hudson.org.apache.tools.ant.taskdefs.AbstractCvsTask;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.taskdefs.LogOutputStream;
import org.apache.tools.ant.taskdefs.cvslib.CvsVersion;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.Enumeration;
import java.util.List;
import java.util.Properties;
import java.util.Vector;
import java.util.StringTokenizer;
import org.apache.tools.ant.taskdefs.ExecuteStreamHandler;
/**
* Examines the output of cvs log and group related changes together.
*
* It produces an XML output representing the list of changes.
* <PRE>
* <FONT color=#0000ff>&lt;!-- Root element --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> changelog <FONT color=#ff00ff>(entry</FONT><FONT color=#ff00ff>+</FONT><FONT color=#ff00ff>)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- CVS Entry --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> entry <FONT color=#ff00ff>(date,author,file</FONT><FONT color=#ff00ff>+</FONT><FONT color=#ff00ff>,msg)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- Date of cvs entry --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> date <FONT color=#ff00ff>(#PCDATA)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- Author of change --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> author <FONT color=#ff00ff>(#PCDATA)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- List of files affected --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> msg <FONT color=#ff00ff>(#PCDATA)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- File changed --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> file <FONT color=#ff00ff>(name,revision,prevrevision</FONT><FONT color=#ff00ff>?</FONT><FONT color=#ff00ff>)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- Name of the file --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> name <FONT color=#ff00ff>(#PCDATA)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- Revision number --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> revision <FONT color=#ff00ff>(#PCDATA)</FONT><FONT color=#6a5acd>&gt;</FONT>
* <FONT color=#0000ff>&lt;!-- Previous revision number --&gt;</FONT>
* <FONT color=#6a5acd>&lt;!ELEMENT</FONT> prevrevision <FONT color=#ff00ff>(#PCDATA)</FONT><FONT color=#6a5acd>&gt;</FONT>
* </PRE>
*
* @version $Revision$ $Date$
* @since Ant 1.5
* @ant.task name="cvschangelog" category="scm"
*/
public class ChangeLogTask extends AbstractCvsTask {
/** User list */
private File m_usersFile;
/** User list */
private Vector m_cvsUsers = new Vector();
/** Input dir */
private File m_dir;
/** Output */
private OutputStream m_output;
/** The earliest date at which to start processing entries. */
private Date m_start;
/** The latest date at which to stop processing entries. */
private Date m_stop;
/**
* To filter out change logs for a certain branch, this variable will be the branch name.
* Otherwise null.
*/
private String branch;
/**
* Filesets containing list of files against which the cvs log will be
* performed. If empty then all files will in the working directory will
* be checked.
*/
private List<String> m_filesets = new ArrayList<String>();
/**
* Set the base dir for cvs.
*
* @param dir The new dir value
*/
public void setDir(final File dir) {
m_dir = dir;
}
public File getDir() {
return m_dir;
}
/**
* Set the output stream for the log.
*
* @param destfile The new destfile value
*/
public void setDeststream(final OutputStream destfile) {
m_output = destfile;
}
/**
* Set a lookup list of user names & addresses
*
* @param usersFile The file containing the users info.
*/
public void setUsersfile(final File usersFile) {
m_usersFile = usersFile;
}
/**
* Add a user to list changelog knows about.
*
* @param user the user
*/
public void addUser(final CvsUser user) {
m_cvsUsers.addElement(user);
}
/**
* Set the date at which the changelog should start.
*
* @param start The date at which the changelog should start.
*/
public void setStart(final Date start) {
m_start = start;
}
public void setBranch(String branch) {
this.branch = branch;
}
/**
* Set the date at which the changelog should stop.
*
* @param stop The date at which the changelog should stop.
*/
public void setEnd(final Date stop) {
m_stop = stop;
}
/**
* Set the number of days worth of log entries to process.
*
* @param days the number of days of log to process.
*/
public void setDaysinpast(final int days) {
final long time = System.currentTimeMillis()
- (long) days * 24 * 60 * 60 * 1000;
setStart(new Date(time));
}
/**
* Adds a file about which cvs logs will be generated.
*
* @param fileName
* fileName relative to {@link #setDir(File)}.
*/
public void addFile(String fileName) {
m_filesets.add(fileName);
}
public void setFile(List<String> files) {
m_filesets = files;
}
// XXX crude but how else to track the parser & handler and still pass to super impl?
private ChangeLogParser parser;
private RedirectingStreamHandler handler;
/**
* Execute task
*
* @exception BuildException if something goes wrong executing the
* cvs command
*/
public void execute() throws BuildException {
File savedDir = m_dir; // may be altered in validate
try {
validate();
final Properties userList = new Properties();
loadUserlist(userList);
for (Enumeration e = m_cvsUsers.elements();
e.hasMoreElements();) {
final CvsUser user = (CvsUser) e.nextElement();
user.validate();
userList.put(user.getUserID(), user.getDisplayname());
}
setCommand("log");
if (m_filesets.isEmpty() || m_filesets.size()>10) {
// if we are going to get logs on large number of files,
// (or if m_files is not specified at all, in which case all the files in the directory is subjec,
// then it's worth spending little time to figure out if we can use
// -S for speed up
CvsVersion myCvsVersion = new CvsVersion();
myCvsVersion.setProject(getProject());
myCvsVersion.setTaskName("cvsversion");
myCvsVersion.setCvsRoot(getCvsRoot());
myCvsVersion.setCvsRsh(getCvsRsh());
myCvsVersion.setPassfile(getPassFile());
myCvsVersion.setDest(m_dir);
myCvsVersion.execute();
if (supportsCvsLogWithSOption(myCvsVersion.getClientVersion())
&& supportsCvsLogWithSOption(myCvsVersion.getServerVersion())) {
addCommandArgument("-S");
}
}
if (null != m_start) {
final SimpleDateFormat outputDate =
new SimpleDateFormat("yyyy-MM-dd");
// Kohsuke patch:
// probably due to timezone difference between server/client and
// the lack of precise specification in the protocol or something,
// sometimes the java.net CVS server (and probably others) don't
// always report all the changes that have happened in the given day.
// so let's take the date range bit wider, to make sure that
// the server sends us all the logs that we care.
//
// the only downside of this change is that it will increase the traffic
// unnecessarily, but given that in Hudson we already narrow down the scope
// by specifying files, this should be acceptable increase.
Date safeStart = new Date(m_start.getTime()-1000L*60*60*24);
// Kohsuke patch until here
// We want something of the form: -d ">=YYYY-MM-dd"
final String dateRange = ">=" + outputDate.format(safeStart);
// Supply '-d' as a separate argument - Bug# 14397
addCommandArgument("-d");
addCommandArgument(dateRange);
}
// Check if list of files to check has been specified
if (!m_filesets.isEmpty()) {
addCommandArgument("--");
for (String file : m_filesets) {
addCommandArgument(file);
}
}
parser = new ChangeLogParser(this);
log("Running "+getCommand()+" at "+m_dir, Project.MSG_VERBOSE);
setDest(m_dir);
try {
super.execute();
} finally {
final String errors = handler.getErrors();
if (null != errors && errors.length()!=0) {
log(errors, Project.MSG_ERR);
}
}
final CVSEntry[] entrySet = parser.getEntrySetAsArray();
final CVSEntry[] filteredEntrySet = filterEntrySet(entrySet);
replaceAuthorIdWithName(userList, filteredEntrySet);
writeChangeLog(filteredEntrySet);
} finally {
m_dir = savedDir;
}
}
protected @Override ExecuteStreamHandler getExecuteStreamHandler(InputStream input) {
return handler = new RedirectingStreamHandler(
// stdout goes to the changelog parser,
// but we also send this to Ant logger so that we can see it at sufficient debug level
new ForkOutputStream(new RedirectingOutputStream(parser),
new LogOutputStream(this,Project.MSG_VERBOSE)),
// stderr goes to the logger, too
new LogOutputStream(this,Project.MSG_WARN),
input);
}
private static final long VERSION_1_11_2 = 11102;
private static final long MULTIPLY = 100;
/**
* Rip off from {@link CvsVersion#supportsCvsLogWithSOption()}
* but we need to check both client and server.
*/
private boolean supportsCvsLogWithSOption(String versionString) {
if (versionString == null) {
return false;
}
StringTokenizer mySt = new StringTokenizer(versionString, ".");
long counter = MULTIPLY * MULTIPLY;
long version = 0;
while (mySt.hasMoreTokens()) {
String s = mySt.nextToken();
int startpos;
// find the first digit char
for (startpos = 0; startpos < s.length(); startpos++)
if (Character.isDigit(s.charAt(startpos)))
break;
// ... and up to the end of this digit set
int i;
for (i = startpos; i < s.length(); i++) {
if (!Character.isDigit(s.charAt(i))) {
break;
}
}
String s2 = s.substring(startpos, i);
version = version + counter * Long.parseLong(s2);
if (counter == 1) {
break;
}
counter = counter / MULTIPLY;
}
return (version >= VERSION_1_11_2);
}
/**
* Validate the parameters specified for task.
*
* @throws BuildException if fails validation checks
*/
private void validate()
throws BuildException {
if (null == m_dir) {
m_dir = getProject().getBaseDir();
}
if (null == m_output) {
final String message = "Destfile must be set.";
throw new BuildException(message);
}
if (!m_dir.exists()) {
final String message = "Cannot find base dir "
+ m_dir.getAbsolutePath();
throw new BuildException(message);
}
if (null != m_usersFile && !m_usersFile.exists()) {
final String message = "Cannot find user lookup list "
+ m_usersFile.getAbsolutePath();
throw new BuildException(message);
}
}
/**
* Load the userlist from the userList file (if specified) and add to
* list of users.
*
* @param userList the file of users
* @throws BuildException if file can not be loaded for some reason
*/
private void loadUserlist(final Properties userList)
throws BuildException {
if (null != m_usersFile) {
try {
userList.load(new FileInputStream(m_usersFile));
} catch (final IOException ioe) {
throw new BuildException(ioe.toString(), ioe);
}
}
}
/**
* Filter the specified entries according to an appropriate rule.
*
* @param entrySet the entry set to filter
* @return the filtered entry set
*/
private CVSEntry[] filterEntrySet(final CVSEntry[] entrySet) {
log("Filtering entries",Project.MSG_VERBOSE);
final Vector results = new Vector();
for (int i = 0; i < entrySet.length; i++) {
final CVSEntry cvsEntry = entrySet[i];
final Date date = cvsEntry.getDate();
if(date==null) {
// skip dates that didn't parse.
log("Filtering out "+cvsEntry+" because it has no date",Project.MSG_VERBOSE);
continue;
}
if (null != m_start && m_start.after(date)) {
//Skip dates that are too early
log("Filtering out "+cvsEntry+" because it's too early compare to "+m_start,Project.MSG_VERBOSE);
continue;
}
if (null != m_stop && m_stop.before(date)) {
//Skip dates that are too late
log("Filtering out "+cvsEntry+" because it's too late compare to "+m_stop,Project.MSG_VERBOSE);
continue;
}
//if tag was specified, it takes care of branches or HEAD, because it does not go out of one. Otherwise HEAD or specified Brach should be filtered
if (null == getTag() && !cvsEntry.containsBranch(branch)) {
// didn't match the branch
log("Filtering out "+cvsEntry+" because it didn't match the branch '"+branch+"'",Project.MSG_VERBOSE);
continue;
}
results.addElement(cvsEntry);
}
final CVSEntry[] resultArray = new CVSEntry[results.size()];
results.copyInto(resultArray);
return resultArray;
}
/**
* replace all known author's id's with their maven specified names
*/
private void replaceAuthorIdWithName(final Properties userList,
final CVSEntry[] entrySet) {
for (int i = 0; i < entrySet.length; i++) {
final CVSEntry entry = entrySet[ i ];
if (userList.containsKey(entry.getAuthor())) {
entry.setAuthor(userList.getProperty(entry.getAuthor()));
}
}
}
/**
* Print changelog to file specified in task.
*
* @param entrySet the entry set to write.
* @throws BuildException if there is an error writing changelog.
*/
private void writeChangeLog(final CVSEntry[] entrySet)
throws BuildException {
OutputStream output = null;
try {
output = m_output;
final PrintWriter writer =
new PrintWriter(new OutputStreamWriter(output, "UTF-8"));
final ChangeLogWriter serializer = new ChangeLogWriter();
serializer.printChangeLog(writer, entrySet);
} catch (final UnsupportedEncodingException uee) {
getProject().log(uee.toString(), Project.MSG_ERR);
} catch (final IOException ioe) {
throw new BuildException(ioe.toString(), ioe);
} finally {
if (null != output) {
try {
output.close();
} catch (final IOException ioe) {
}
}
}
}
}
@@ -1,104 +0,0 @@
/*
* Copyright 2002-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
import org.apache.commons.lang.time.FastDateFormat;
import java.io.PrintWriter;
import java.util.Enumeration;
import java.util.TimeZone;
/**
* Class used to generate an XML changelog.
*
* @version $Revision$ $Date$
*/
class ChangeLogWriter {
private static final TimeZone UTC = TimeZone.getTimeZone("UTC");
/** output format for dates written to xml file */
private static final FastDateFormat c_outputDate
= FastDateFormat.getInstance("yyyy-MM-dd", UTC);
/** output format for times written to xml file */
private static final FastDateFormat c_outputTime
= FastDateFormat.getInstance("HH:mm", UTC);
/**
* Print out the specified entries.
*
* @param output writer to which to send output.
* @param entries the entries to be written.
*/
public void printChangeLog(final PrintWriter output,
final CVSEntry[] entries) {
output.println("<?xml version=\"1.0\" encoding=\"UTF-8\"?>");
output.println("<changelog>");
for (int i = 0; i < entries.length; i++) {
final CVSEntry entry = entries[i];
printEntry(output, entry);
}
output.println("</changelog>");
output.flush();
output.close();
}
/**
* Print out an individual entry in changelog.
*
* @param entry the entry to print
* @param output writer to which to send output.
*/
private void printEntry(final PrintWriter output, final CVSEntry entry) {
output.println("\t<entry>");
output.println("\t\t<date>" + c_outputDate.format(entry.getDate())
+ "</date>");
output.println("\t\t<time>" + c_outputTime.format(entry.getDate())
+ "</time>");
output.println("\t\t<author><![CDATA[" + entry.getAuthor()
+ "]]></author>");
final Enumeration enumeration = entry.getFiles().elements();
while (enumeration.hasMoreElements()) {
final RCSFile file = (RCSFile) enumeration.nextElement();
output.println("\t\t<file>");
output.println("\t\t\t<name>" + file.getName() + "</name>");
if(file.getFullName()!=null)
output.println("\t\t\t<fullName>" + file.getFullName() + "</fullName>");
output.println("\t\t\t<revision>" + file.getRevision()
+ "</revision>");
final String previousRevision = file.getPreviousRevision();
if (previousRevision != null) {
output.println("\t\t\t<prevrevision>" + previousRevision
+ "</prevrevision>");
}
if(file.isDead())
output.println("\t\t\t<dead />");
output.println("\t\t</file>");
}
output.println("\t\t<msg><![CDATA[" + entry.getComment() + "]]></msg>");
output.println("\t</entry>");
}
}
@@ -1,93 +0,0 @@
/*
* Copyright 2002-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
import org.apache.tools.ant.BuildException;
/**
* Represents a CVS user with a userID and a full name.
*
* @version $Revision$ $Date$
*/
public class CvsUser {
/** The user's Id */
private String m_userID;
/** The user's full name */
private String m_displayName;
/**
* Set the user's fullname
*
* @param displayName the user's full name
*/
public void setDisplayname(final String displayName) {
m_displayName = displayName;
}
/**
* Set the user's id
*
* @param userID the user's new id value.
*/
public void setUserid(final String userID) {
m_userID = userID;
}
/**
* Get the user's id.
*
* @return The userID value
*/
String getUserID() {
return m_userID;
}
/**
* Get the user's full name
*
* @return the user's full name
*/
String getDisplayname() {
return m_displayName;
}
/**
* validate that this object is configured.
*
* @exception BuildException if the instance has not be correctly
* configured.
*/
void validate() throws BuildException {
if (null == m_userID) {
final String message = "Username attribute must be set.";
throw new BuildException(message);
}
if (null == m_displayName) {
final String message =
"Displayname attribute must be set for userID " + m_userID;
throw new BuildException(message);
}
}
}
@@ -1,77 +0,0 @@
/*
* Copyright 2002-2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
/**
* Represents a RCS File change.
*
* @version $Revision$ $Date$
*/
class RCSFile {
private String m_name;
private String m_fullName;
private String m_revision;
private String m_previousRevision;
private boolean m_dead;
private String m_branch;
RCSFile(final String name,
final String fullName,
final String revision,
final String previousRevision,
final String branch,
final boolean dead) {
m_name = name;
m_fullName = fullName;
m_revision = revision;
if (!revision.equals(previousRevision)) {
m_previousRevision = previousRevision;
}
m_branch = branch;
m_dead = dead;
}
String getName() {
return m_name;
}
public String getFullName() {
return m_fullName;
}
String getRevision() {
return m_revision;
}
String getPreviousRevision() {
return m_previousRevision;
}
boolean isDead() {
return m_dead;
}
/**
* Gets the name of this branch, if available.
*/
String getBranch() {
return m_branch;
}
}
@@ -1,51 +0,0 @@
/*
* Copyright 2002,2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
import org.apache.tools.ant.taskdefs.LogOutputStream;
/**
* A dummy stream that just passes stuff to the parser.
*
* @version $Revision$ $Date$
*/
class RedirectingOutputStream
extends LogOutputStream {
private final ChangeLogParser parser;
/**
* Creates a new instance of this class.
*
* @param parser the parser to which output is sent.
*/
public RedirectingOutputStream(final ChangeLogParser parser) {
super(null, 0);
this.parser = parser;
}
/**
* Logs a line to the log system of ant.
*
* @param line the line to log.
*/
protected void processLine(final String line) {
parser.stdout(line);
}
}
@@ -1,68 +0,0 @@
/*
* Copyright 2002,2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package hudson.org.apache.tools.ant.taskdefs.cvslib;
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.taskdefs.PumpStreamHandler;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
/**
* A dummy stream handler that just passes stuff to the parser.
*
* @version $Revision$ $Date$
*/
class RedirectingStreamHandler extends PumpStreamHandler {
RedirectingStreamHandler(final ChangeLogParser parser) {
this(new RedirectingOutputStream(parser), null);
}
RedirectingStreamHandler(OutputStream out, InputStream in) {
this(out, new ByteArrayOutputStream(), in);
}
RedirectingStreamHandler(OutputStream out, OutputStream err, InputStream in) {
super(out, err, in);
}
String getErrors() {
try {
final ByteArrayOutputStream error
= (ByteArrayOutputStream) getErr();
return error.toString("ASCII");
} catch (final Exception e) {
return null;
}
}
public void stop() {
super.stop();
try {
getErr().close();
getOut().close();
} catch (final IOException e) {
// plain impossible
throw new BuildException(e);
}
}
}
@@ -1,27 +0,0 @@
<!--
The MIT License
Copyright (c) 2004-2009, Sun Microsystems, Inc., Kohsuke Kawaguchi
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
-->
<html><body>
Fork of Ant CVS <tt>changelog</tt> task to work around issues.
</body></html>