/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* See LICENSE.txt included in this distribution for the specific
* language governing permissions and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at LICENSE.txt.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright (c) 2008, 2011, Oracle and/or its affiliates. All rights reserved.
*/
package org.opensolaris.opengrok.history;
import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.regex.Pattern;
import org.opensolaris.opengrok.configuration.Configuration;
import org.opensolaris.opengrok.util.Executor;
import org.opensolaris.opengrok.util.IOUtils;
/**
* Access to a ClearCase repository.
*/
public class ClearCaseRepository extends Repository {
private static final long serialVersionUID = 1L;
private static final Logger logger =
Logger.getLogger(ClearCaseRepository.class.getName());
/** The property name used to obtain the client command for this repository. */
public static final String CMD_PROPERTY_KEY =
Configuration.PROPERTY_KEY_PREFIX + "history.ClearCase";
/** The command to use to access the repository if none was given explicitly */
public static final String CMD_FALLBACK = "cleartool";
private boolean verbose;
/**
* Create a new instance of type {@code ClearCase}.
*/
public ClearCaseRepository() {
type = "ClearCase";
datePattern = "yyyyMMdd.HHmmss";
}
/**
* Use verbose log messages, or just the summary
* @return true if verbose log messages are used for this repository
*/
public boolean isVerbose() {
return verbose;
}
/**
* Specify if verbose log messages or just the summary should be used
* @param verbose set to true if verbose messages should be used
*/
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
/**
* Get an executor to be used for retrieving the history log for the
* named file.
*
* @param file The file to retrieve history for (canonical path incl. source
* root).
* @return An Executor ready to be started
*/
Executor getHistoryLogExecutor(final File file) throws IOException {
String abs = file.getCanonicalPath();
String filename = "";
if (abs.length() > directoryName.length()) {
filename = abs.substring(directoryName.length() + 1);
}
List<String> cmd = new ArrayList<String>();
ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
cmd.add(this.cmd);
cmd.add("lshistory");
if (file.isDirectory()) {
cmd.add("-dir");
}
cmd.add("-fmt");
cmd.add("%e\n%Nd\n%Fu (%u)\n%Vn\n%Nc\n.\n");
cmd.add(filename);
return new Executor(cmd, new File(getDirectoryName()));
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("resource")
@Override
public InputStream getHistoryGet(String parent, String basename, String rev)
{
InputStream ret = null;
File directory = new File(directoryName);
Process process = null;
try {
String filename = (new File(parent, basename)).getCanonicalPath()
.substring(directoryName.length() + 1);
final File tmp = File.createTempFile("opengrok", "tmp");
String tmpName = tmp.getCanonicalPath();
// cleartool can't get to a previously existing file
if (tmp.exists() && !tmp.delete()) {
logger.warning("Failed to remove temporary file used by history cache");
}
String decorated = filename + "@@" + rev;
ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
String argv[] = {cmd, "get", "-to", tmpName, decorated};
process = Runtime.getRuntime().exec(argv, null, directory);
drainStream(process.getInputStream());
if(waitFor(process) != 0) {
return null;
}
ret = new BufferedInputStream(new FileInputStream(tmp)) {
@Override
public void close() throws IOException {
super.close();
// delete the temporary file on close
if (!tmp.delete()) {
// failed, lets do the next best thing then ..
// delete it on JVM exit
tmp.deleteOnExit();
}
}
};
} catch (Exception exp) {
logger.warning("Failed to get history for '" + parent
+ File.separator + basename + "': " + exp.getMessage());
logger.log(Level.FINE, "getHistoryGet", exp);
} finally {
// Clean up zombie-processes...
if (process != null) {
try {
process.exitValue();
} catch (IllegalThreadStateException exp) {
// the process is still running??? just kill it..
process.destroy();
}
}
}
return ret;
}
/**
* Drain all data from a stream and close it.
* @param in the stream to drain
* @throws IOException if an I/O error occurs
*/
private static void drainStream(InputStream in) throws IOException {
while (true) {
long skipped = 0;
try {
skipped = in.skip(32768L);
} catch (IOException ioe) {
// ignored - stream isn't seekable, but skipped variable still
// has correct value.
logger.log(Level.FINEST, "Stream not seekable", ioe);
}
if (skipped == 0 && in.read() == -1) {
// No bytes skipped, checked that we've reached EOF with read()
break;
}
}
IOUtils.close(in);
}
/**
* {@inheritDoc}
*/
@Override
public Annotation annotate(File file, String revision) throws IOException {
ArrayList<String> argv = new ArrayList<String>();
ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
argv.add(cmd);
argv.add("annotate");
argv.add("-nheader");
argv.add("-out");
argv.add("-");
argv.add("-f");
argv.add("-fmt");
argv.add("%u|%Vn|");
if (revision != null) {
argv.add(revision);
}
argv.add(file.getName());
ProcessBuilder pb = new ProcessBuilder(argv);
pb.directory(file.getParentFile());
Process process = null;
BufferedReader in = null;
try {
process = pb.start();
in = new BufferedReader(new InputStreamReader(process.getInputStream()));
Annotation a = new Annotation(file.getName());
String line;
while ((line = in.readLine()) != null) {
String parts[] = line.split("\\|");
String aAuthor = parts[0];
String aRevision = parts[1];
aRevision = aRevision.replace('\\', '/');
a.addLine(aRevision, aAuthor);
}
return a;
} finally {
IOUtils.close(in);
if (process != null) {
try {
process.exitValue();
} catch (IllegalThreadStateException e) {
process.destroy();
}
}
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean fileHasAnnotation(File file) {
return true;
}
private static int waitFor(Process process) {
do {
try {
return process.waitFor();
} catch (InterruptedException exp) {
// ok
}
} while (true);
}
/**
* {@inheritDoc}
*/
@SuppressWarnings("PMD.EmptyWhileStmt")
@Override
public void update() throws IOException {
Process process = null;
BufferedReader in = null;
try {
File directory = new File(getDirectoryName());
// Check if this is a snapshot view
ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
String[] argv = { cmd, "catcs" };
process = Runtime.getRuntime().exec(argv, null, directory);
in = new BufferedReader(new InputStreamReader(process.getInputStream()));
boolean snapshot = false;
String line;
while (!snapshot && (line = in.readLine()) != null) {
snapshot = line.startsWith("load");
}
if (waitFor(process) != 0) {
return;
}
IOUtils.close(in);
in = null; // To avoid double close in finally clause
if (snapshot) {
// It is a snapshot view, we need to update it manually
ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
argv = new String[]{cmd, "update", "-overwrite", "-f"};
process = Runtime.getRuntime().exec(argv, null, directory);
in = new BufferedReader(new InputStreamReader(process.getInputStream()));
// consume output
while ((line = in.readLine()) != null) {
// do nothing
}
if (waitFor(process) != 0) {
return;
}
}
} finally {
IOUtils.close(in);
if (process != null) {
try {
process.exitValue();
} catch (IllegalThreadStateException e) {
process.destroy();
}
}
}
}
/**
* {@inheritDoc}
*/
@Override
public boolean fileHasHistory(File file) {
// Todo: is there a cheap test for whether ClearCase has history
// available for a file?
// Otherwise, this is harmless, since ClearCase's commands will just
// print nothing if there is no history.
return true;
}
/**
* {@inheritDoc}
*/
@Override
public boolean isWorking() {
if (working == null) {
ensureCommand(CMD_PROPERTY_KEY, CMD_FALLBACK);
working = checkCmd(cmd, "–version");
}
return working.booleanValue();
}
/**
* {@inheritDoc}
*/
@Override
public boolean isRepositoryFor(File file) {
// if the parent contains a file named "view.dat" or
// the parent is named "vobs" or the canonical path
// is found in "cleartool lsvob -s"
File f = new File(file, "view.dat");
if (f.exists()) {
return true;
} else if (file.isDirectory() && file.getName().equalsIgnoreCase("vobs")) {
return true;
} else if (isWorking()) {
try {
String canonicalPath = file.getCanonicalPath();
for (String vob : getAllVobs()) {
if (canonicalPath.equalsIgnoreCase(vob)) {
return true;
}
}
} catch (IOException e) {
logger.warning("Could not get canonical path for '" + file
+ "': " + e.getMessage());
logger.log(Level.FINE, "isRepositoryFor", e);
}
}
return false;
}
private static class VobsHolder {
@SuppressWarnings("synthetic-access")
public static String[] vobs = runLsvob();
}
private static String[] getAllVobs() {
return VobsHolder.vobs;
}
private static final ClearCaseRepository testRepo = new ClearCaseRepository();
private static String[] runLsvob() {
if (testRepo.isWorking()) {
Executor exec = new Executor(new String[] {testRepo.cmd, "lsvob", "-s"});
int rc;
if ((rc = exec.exec(true)) == 0) {
String output = exec.getOutputString();
if (output == null) {
logger.warning("[cleartool lsvob -s] output was null");
return new String[0];
}
String sep = System.getProperty("line.separator");
String[] vobs = output.split(Pattern.quote(sep));
logger.log(Level.FINE, "Found VOBs: {0}", Arrays.asList(vobs));
return vobs;
}
logger.warning("[cleartool lsvob -s] returned non-zero status " + rc);
}
return new String[0];
}
/**
* {@inheritDoc}
*/
@Override
public boolean hasHistoryForDirectories() {
return true;
}
/**
* {@inheritDoc}
*/
@Override
public History getHistory(File file) throws HistoryException {
return new ClearCaseHistoryParser().parse(file, this);
}
}