org.apache.tools.ant.taskdefs.optional.pvcs.Pvcs Maven / Gradle / Ivy
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You 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
*
* https://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 org.apache.tools.ant.taskdefs.optional.pvcs;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.OutputStream;
import java.nio.file.Files;
import java.text.MessageFormat;
import java.text.ParseException;
import java.util.Random;
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.taskdefs.Execute;
import org.apache.tools.ant.taskdefs.ExecuteStreamHandler;
import org.apache.tools.ant.taskdefs.LogOutputStream;
import org.apache.tools.ant.taskdefs.LogStreamHandler;
import org.apache.tools.ant.taskdefs.PumpStreamHandler;
import org.apache.tools.ant.types.Commandline;
import org.apache.tools.ant.util.FileUtils;
/**
*
* Extracts the latest edition of the source code from a PVCS repository.
* PVCS is a version control system
* developed by Merant.
*
* Before using this tag, the user running ant must have access to the commands
* of PVCS (get and pcli) and must have access to the repository. Note that the way to specify
* the repository is platform dependent so use property to specify location of repository.
*
* This version has been tested against PVCS version 6.5 and 6.6 under Windows and Solaris.
*
* 19-04-2001 The task now has a more robust
* parser. It allows for platform independent file paths
* and supports file names with (). Thanks to Erik Husby for
* bringing the bug to my attention.
*
* 27-04-2001
UNC paths are now handled properly.
* Fix provided by Don Jeffery. He also added an UpdateOnly flag
* that, when true, conditions the PVCS get using the -U option to only
* update those files that have a modification time (in PVCS) that is newer
* than the existing workfile.
*
* 25-10-2002
Added a revision attribute that currently is a
* synonym for label, but in a future release the behavior of the label
* attribute will change to use the -v option of GET. See bug #13847 for
* discussion.
*
*/
public class Pvcs extends Task {
// CheckStyle - magic numbers
// checking for "X:\ 0=dquote,1=letter,2=:,3=\
private static final int POS_1 = 1;
private static final int POS_2 = 2;
private static final int POS_3 = 3;
/**
* Constant for the thing to execute
*/
private static final String PCLI_EXE = "pcli";
/**
* Constant for the thing to execute
*/
private static final String GET_EXE = "get";
private String pvcsbin;
private String repository;
private String pvcsProject;
private Vector pvcsProjects;
private String workspace;
private String force;
private String promotiongroup;
private String label;
private String revision;
private boolean ignorerc;
private boolean updateOnly;
private String filenameFormat;
private String lineStart;
private String userId;
private String config;
/**
* Creates a Pvcs object
*/
public Pvcs() {
super();
pvcsProject = null;
pvcsProjects = new Vector<>();
workspace = null;
repository = null;
pvcsbin = null;
force = null;
promotiongroup = null;
label = null;
ignorerc = false;
updateOnly = false;
lineStart = "\"P:";
filenameFormat = "{0}-arc({1})";
}
/**
* Run the command.
* @param cmd the command line to use.
* @param out the output stream handler to use.
* @return the exit code of the command.
*/
protected int runCmd(Commandline cmd, ExecuteStreamHandler out) {
try {
Project aProj = getProject();
Execute exe = new Execute(out);
exe.setAntRun(aProj);
exe.setWorkingDirectory(aProj.getBaseDir());
exe.setCommandline(cmd.getCommandline());
return exe.execute();
} catch (IOException e) {
String msg = "Failed executing: " + cmd.toString()
+ ". Exception: " + e.getMessage();
throw new BuildException(msg, getLocation());
}
}
private String getExecutable(String exe) {
StringBuilder correctedExe = new StringBuilder();
if (getPvcsbin() != null) {
if (pvcsbin.endsWith(File.separator)) {
correctedExe.append(pvcsbin);
} else {
correctedExe.append(pvcsbin).append(File.separator);
}
}
return correctedExe.append(exe).toString();
}
/**
* @throws BuildException Something is stopping the build...
*/
@Override
public void execute() throws BuildException {
int result = 0;
if (repository == null || repository.trim().isEmpty()) {
throw new BuildException("Required argument repository not specified");
}
// Check workspace exists
// Launch PCLI listversionedfiles -z -aw
// Capture output
// build the command line from what we got the format is
Commandline commandLine = new Commandline();
commandLine.setExecutable(getExecutable(PCLI_EXE));
commandLine.createArgument().setValue("lvf");
commandLine.createArgument().setValue("-z");
commandLine.createArgument().setValue("-aw");
if (getWorkspace() != null) {
commandLine.createArgument().setValue("-sp" + getWorkspace());
}
commandLine.createArgument().setValue("-pr" + getRepository());
String uid = getUserId();
if (uid != null) {
commandLine.createArgument().setValue("-id" + uid);
}
// default pvcs project is "/"
if (getPvcsproject() == null && getPvcsprojects().isEmpty()) {
pvcsProject = "/";
}
if (getPvcsproject() != null) {
commandLine.createArgument().setValue(getPvcsproject());
}
if (!getPvcsprojects().isEmpty()) {
for (PvcsProject pvcsProject : getPvcsprojects()) {
String projectName = pvcsProject.getName();
if (projectName == null || projectName.trim().isEmpty()) {
throw new BuildException("name is a required attribute of pvcsproject");
}
commandLine.createArgument().setValue(projectName);
}
}
File tmp = null;
File tmp2 = null;
try {
Random rand = new Random(System.currentTimeMillis());
tmp = new File("pvcs_ant_" + rand.nextLong() + ".log");
OutputStream fos = Files.newOutputStream(tmp.toPath());
tmp2 = new File("pvcs_ant_" + rand.nextLong() + ".log");
log(commandLine.describeCommand(), Project.MSG_VERBOSE);
try {
result = runCmd(commandLine, new PumpStreamHandler(fos,
new LogOutputStream(this, Project.MSG_WARN)));
} finally {
FileUtils.close(fos);
}
if (Execute.isFailure(result) && !ignorerc) {
String msg = "Failed executing: " + commandLine.toString();
throw new BuildException(msg, getLocation());
}
if (!tmp.exists()) {
throw new BuildException("Communication between ant and pvcs "
+ "failed. No output generated from executing PVCS "
+ "commandline interface \"pcli\" and \"get\"");
}
// Create folders in workspace
log("Creating folders", Project.MSG_INFO);
createFolders(tmp);
// Massage PCLI lvf output transforming '\' to '/' so get command works appropriately
massagePCLI(tmp, tmp2);
// Launch get on output captured from PCLI lvf
commandLine.clearArgs();
commandLine.setExecutable(getExecutable(GET_EXE));
if (getConfig() != null && !getConfig().isEmpty()) {
commandLine.createArgument().setValue("-c" + getConfig());
}
if (getForce() != null && getForce().equals("yes")) {
commandLine.createArgument().setValue("-Y");
} else {
commandLine.createArgument().setValue("-N");
}
if (getPromotiongroup() != null) {
commandLine.createArgument().setValue("-G"
+ getPromotiongroup());
} else {
if (getLabel() != null) {
commandLine.createArgument().setValue("-v" + getLabel());
} else {
if (getRevision() != null) {
commandLine.createArgument().setValue("-r" + getRevision());
}
}
}
if (updateOnly) {
commandLine.createArgument().setValue("-U");
}
commandLine.createArgument().setValue("@" + tmp2.getAbsolutePath());
log("Getting files", Project.MSG_INFO);
log("Executing " + commandLine.toString(), Project.MSG_VERBOSE);
result = runCmd(commandLine,
new LogStreamHandler(this, Project.MSG_INFO, Project.MSG_WARN));
if (result != 0 && !ignorerc) {
String msg = "Failed executing: " + commandLine.toString()
+ ". Return code was " + result;
throw new BuildException(msg, getLocation());
}
} catch (ParseException | IOException e) {
String msg = "Failed executing: " + commandLine.toString()
+ ". Exception: " + e.getMessage();
throw new BuildException(msg, getLocation());
} finally {
if (tmp != null) {
tmp.delete();
}
if (tmp2 != null) {
tmp2.delete();
}
}
}
/**
* Parses the file and creates the folders specified in the output section
*/
private void createFolders(File file) throws IOException, ParseException {
try (BufferedReader in = new BufferedReader(new FileReader(file))) {
MessageFormat mf = new MessageFormat(getFilenameFormat());
String line = in.readLine();
while (line != null) {
log("Considering \"" + line + "\"", Project.MSG_VERBOSE);
if (line.startsWith("\"\\") // Checking for "\
|| line.startsWith("\"/") // or "/
// or "X:\...
|| (line.length() > POS_3 && line.startsWith("\"")
&& Character.isLetter(line.charAt(POS_1))
&& String.valueOf(line.charAt(POS_2)).equals(":")
&& String.valueOf(line.charAt(POS_3)).equals("\\"))) {
Object[] objs = mf.parse(line);
String f = (String) objs[1];
// Extract the name of the directory from the filename
int index = f.lastIndexOf(File.separator);
if (index > -1) {
File dir = new File(f.substring(0, index));
if (dir.exists()) {
log(dir.getAbsolutePath() + " exists. Skipping",
Project.MSG_VERBOSE);
} else {
log("Creating " + dir.getAbsolutePath(),
Project.MSG_VERBOSE);
if (dir.mkdirs() || dir.isDirectory()) {
log("Created " + dir.getAbsolutePath(),
Project.MSG_INFO);
} else {
log("Failed to create "
+ dir.getAbsolutePath(),
Project.MSG_INFO);
}
}
} else {
log("File separator problem with " + line,
Project.MSG_WARN);
}
} else {
log("Skipped \"" + line + "\"", Project.MSG_VERBOSE);
}
line = in.readLine();
}
}
}
/**
* Simple hack to handle the PVCS command-line tools botch when
* handling UNC notation.
* @throws IOException if there is an error.
*/
private void massagePCLI(File in, File out)
throws IOException {
try (BufferedReader inReader = new BufferedReader(new FileReader(in));
BufferedWriter outWriter = new BufferedWriter(new FileWriter(out))) {
for (String line : (Iterable) () -> inReader.lines()
.map(s -> s.replace('\\', '/')).iterator()) {
outWriter.write(line);
outWriter.newLine();
}
}
}
/**
* Get network name of the PVCS repository
* @return String
*/
public String getRepository() {
return repository;
}
/**
* The filenameFormat attribute defines a MessageFormat string used
* to parse the output of the pcli command. It defaults to
* {0}-arc({1}). Repositories where the archive
* extension is not -arc should set this.
* @return the filename format attribute.
*/
public String getFilenameFormat() {
return filenameFormat;
}
/**
* The format of the folder names; optional.
* This must be in a format suitable for
* java.text.MessageFormat.
* Index 1 of the format will be used as the file name.
* Defaults to {0}-arc({1})
* @param f the format to use.
*/
public void setFilenameFormat(String f) {
filenameFormat = f;
}
/**
* The lineStart attribute is used to parse the output of the pcli
* command. It defaults to "P:. The parser already
* knows about / and \\, this property is useful in cases where the
* repository is accessed on a Windows platform via a drive letter
* mapping.
* @return the lineStart attribute.
*/
public String getLineStart() {
return lineStart;
}
/**
* What a valid return value from PVCS looks like
* when it describes a file. Defaults to "P:.
* If you are not using an UNC name for your repository and the
* drive letter P is incorrect for your setup, you may
* need to change this value, UNC names will always be
* accepted.
* @param l the value to use.
*/
public void setLineStart(String l) {
lineStart = l;
}
/**
* The network name of the PVCS repository; required.
* @param repo String
*/
public void setRepository(String repo) {
repository = repo;
}
/**
* Get name of the project in the PVCS repository
* @return String
*/
public String getPvcsproject() {
return pvcsProject;
}
/**
* The project within the PVCS repository to extract files from;
* optional, default "/"
* @param prj String
*/
public void setPvcsproject(String prj) {
pvcsProject = prj;
}
/**
* Get name of the project in the PVCS repository
* @return Vector
*/
public Vector getPvcsprojects() {
return pvcsProjects;
}
/**
* Get name of the workspace to store the retrieved files
* @return String
*/
public String getWorkspace() {
return workspace;
}
/**
* Workspace to use; optional.
* By specifying a workspace, the files are extracted to that location.
* A PVCS workspace is a name for a location of the workfiles and
* isn't as such the location itself.
* You define the location for a workspace using the PVCS GUI clients.
* If this isn't specified the default workspace for the current user is used.
* @param ws String
*/
public void setWorkspace(String ws) {
workspace = ws;
}
/**
* Get name of the PVCS bin directory
* @return String
*/
public String getPvcsbin() {
return pvcsbin;
}
/**
* Specifies the location of the PVCS bin directory; optional if on the PATH.
* On some systems the PVCS executables pcli
* and get are not found in the PATH. In such cases this attribute
* should be set to the bin directory of the PVCS installation containing
* the executables mentioned before. If this attribute isn't specified the
* tag expects the executables to be found using the PATH environment variable.
* @param bin PVCS bin directory
* @todo use a File setter and resolve paths.
*/
public void setPvcsbin(String bin) {
pvcsbin = bin;
}
/**
* Get value of force
* @return String
*/
public String getForce() {
return force;
}
/**
* Specifies the value of the force argument; optional.
* If set to yes all files that exists and are
* writable are overwritten. Default no causes the files
* that are writable to be ignored. This stops the PVCS command
* get to stop asking questions!
* @todo make a boolean setter
* @param f String (yes/no)
*/
public void setForce(String f) {
force = "yes".equalsIgnoreCase(f) ? "yes" : "no";
}
/**
* Get value of promotiongroup
* @return String
*/
public String getPromotiongroup() {
return promotiongroup;
}
/**
* Specifies the name of the promotiongroup argument
* @param w String
*/
public void setPromotiongroup(String w) {
promotiongroup = w;
}
/**
* Get value of label
* @return String
*/
public String getLabel() {
return label;
}
/**
* Only files marked with this label are extracted; optional.
* @param l String
*/
public void setLabel(String l) {
label = l;
}
/**
* Get value of revision
* @return String
*/
public String getRevision() {
return revision;
}
/**
* Only files with this revision are extract; optional.
* @param r String
*/
public void setRevision(String r) {
revision = r;
}
/**
* Get value of ignorereturncode
* @return String
*/
public boolean getIgnoreReturnCode() {
return ignorerc;
}
/**
* If set to true the return value from executing the pvcs
* commands are ignored; optional, default false.
* @param b a boolean value.
*/
public void setIgnoreReturnCode(boolean b) {
ignorerc = b;
}
/**
* Specify a project within the PVCS repository to extract files from.
* @param p the pvcs project to use.
*/
public void addPvcsproject(PvcsProject p) {
pvcsProjects.addElement(p);
}
/**
* get the updateOnly attribute.
* @return the updateOnly attribute.
*/
public boolean getUpdateOnly() {
return updateOnly;
}
/**
* If set to true files are fetched only if
* newer than existing local files; optional, default false.
* @param l a boolean value.
*/
public void setUpdateOnly(boolean l) {
updateOnly = l;
}
/**
* returns the path of the configuration file to be used
* @return the path of the config file
*/
public String getConfig() {
return config;
}
/**
* Sets a configuration file other than the default to be used.
* These files have a .cfg extension and are often found in archive or pvcsprop folders.
* @param f config file - can be given absolute or relative to ant basedir
*/
public void setConfig(File f) {
config = f.toString();
}
/**
* Get the userid.
* @return the userid.
*/
public String getUserId() {
return userId;
}
/**
* User ID
* @param u the value to use.
*/
public void setUserId(String u) {
userId = u;
}
}