plugins/cvs/smartcvs-src/org/netbeans/lib/cvsclient/admin/AdminWriter.java

/*
 *                 Sun Public License Notice
 *
 * The contents of this file are subject to the Sun Public License
 * Version 1.0 (the "License"). You may not use this file except in
 * compliance with the License. A copy of the License is available at
 * http://www.sun.com/
 *
 * The Original Code is NetBeans. The Initial Developer of the Original
 * Code is Sun Microsystems, Inc. Portions Copyright 1997-2000 Sun
 * Microsystems, Inc. All Rights Reserved.
 */
package org.netbeans.lib.cvsclient.admin;

import com.intellij.openapi.util.io.FileUtil;
import org.jetbrains.annotations.NonNls;
import org.netbeans.lib.cvsclient.CvsRoot;
import org.netbeans.lib.cvsclient.IClientEnvironment;
import org.netbeans.lib.cvsclient.SmartCvsSrcBundle;
import org.netbeans.lib.cvsclient.file.*;
import org.netbeans.lib.cvsclient.util.BugLog;

import java.io.*;

/**
 * A handler for administrative information that maintains full compatibility
 * with the one employed by the original C implementation of a CVS client.
 * <p>This implementation strives to provide complete compatibility with
 * the standard CVS client, so that operations on locally checked-out
 * files can be carried out by either this library or the standard client
 * without causing the other to fail. Any such failure should be considered
 * a bug in this library.
 *
 * @author Robert Greig
 */
public final class AdminWriter implements IAdminWriter {

  private final String myLineSeparator;
  protected final String myCharset;
  private final EntriesWriter myEntriesWriter;

  // for tests only!
  public static boolean WRITE_RELATIVE_PATHS = true;

  @NonNls private static final String CVS_DIR_NAME = "CVS";
  @NonNls private static final String TAG_FILE_NAME = "Tag";
  @NonNls private static final String ENTRIES_STATIC_FILE_NAME = "Entries.Static";
  @NonNls private static final String CVS_TEMPLATE_FILE_PATH = "CVS/Template";
  @NonNls private static final String ROOT_FILE_NAME = "Root";
  @NonNls private static final String REPOSITORY_FILE_NAME = "Repository";
  @NonNls private static final String ENTRIES_FILE_NAME = "Entries";
  @NonNls private static final String CVS_ROOT_FILE_PATH = "CVS/Root";
  @NonNls private static final String CVS_REPOSITORY_FILE_PATH = "CVS/Repository";
  @NonNls private static final String CVS_BASE_FILE_PATH = "CVS/Base/";
  @NonNls private static final String CVS_BASEREV_FILE_PATH = "CVS/Baserev";

  // Setup ==================================================================
  public AdminWriter(String lineSeparator, final String charset, final EntriesWriter creator) {
    myLineSeparator = lineSeparator;
    myCharset = charset;
    myEntriesWriter = creator;
  }

  public AdminWriter(String lineSeparator, final String charset) {
    this(lineSeparator, charset, new SimpleEntriesWriter(charset, lineSeparator));
  }

  // Implemented ============================================================

  public void ensureCvsDirectory(DirectoryObject directoryObject, String repositoryPath, CvsRoot cvsRoot, ICvsFileSystem cvsFileSystem)
    throws IOException {
    final File cvsDirectory = ensureCvsDirectory(directoryObject, cvsFileSystem);
    // now ensure that the Root and Repository files exist
    ensureExistingRootFile(cvsDirectory, cvsRoot);
    ensureRepositoryFile(cvsDirectory, WRITE_RELATIVE_PATHS ? cvsFileSystem.getRelativeRepositoryPath(repositoryPath) : repositoryPath);
    ensureExistingEntriesFile(cvsDirectory);
  }

  public void removeEntryForFile(AbstractFileObject fileObject, ICvsFileSystem cvsFileSystem) throws IOException {
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    final File directory = file.getParentFile();
    if (directory == null) {
      throw new IOException(SmartCvsSrcBundle.message("file.does.not.have.a.parent.directory.error.message", file));
    }

    final EntriesHandler entriesHandler = new EntriesHandler(directory);
    final boolean entriesUpdated = entriesHandler.read(myCharset);
    final boolean entryRemoved = entriesHandler.getEntries().removeEntry(file.getName());
    if (entriesUpdated || entryRemoved) {
      entriesHandler.write(myLineSeparator, myCharset);
    }
  }

  public void pruneDirectory(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) {
    deleteDirectoryRecursively(cvsFileSystem.getLocalFileSystem().getFile(directoryObject));
    deleteDirectoryRecursively(cvsFileSystem.getAdminFileSystem().getFile(directoryObject));
  }

  public void setStickyTagForDirectory(DirectoryObject directoryObject, String tag, ICvsFileSystem cvsFileSystem) throws IOException {
    final File cvsDirectory = new File(cvsFileSystem.getAdminFileSystem().getFile(directoryObject), CVS_DIR_NAME);
    if (!cvsDirectory.isDirectory()) {
      return;
    }

    final File tagFile = new File(cvsDirectory, TAG_FILE_NAME);
    if (tag != null) {
      FileUtils.writeLine(tagFile, tag);
    }
    else {
      FileUtil.delete(tagFile);
    }
  }

  public void editFile(FileObject fileObject, Entry entry, ICvsFileSystem cvsFileSystem, IFileReadOnlyHandler fileReadOnlyHandler)
    throws IOException {
    createBaserevEntry(fileObject, cvsFileSystem, entry);

    final File localFile = cvsFileSystem.getLocalFileSystem().getFile(fileObject);
    FileUtils.copyFile(localFile, getEditBackupFile(fileObject, cvsFileSystem));
    fileReadOnlyHandler.setFileReadOnly(localFile, false);
  }

  public void uneditFile(FileObject fileObject, ICvsFileSystem cvsFileSystem, IFileReadOnlyHandler fileReadOnlyHandler) throws IOException {
    final File editBackupFile = getEditBackupFile(fileObject, cvsFileSystem);
    if (!editBackupFile.isFile()) {
      return;
    }

    FileUtil.delete(editBackupFile);
    removeBaserevEntry(fileObject, cvsFileSystem);

    fileReadOnlyHandler.setFileReadOnly(cvsFileSystem.getLocalFileSystem().getFile(fileObject), true);
  }

  public void setEntriesDotStatic(DirectoryObject directoryObject, boolean set, ICvsFileSystem cvsFileSystem) throws IOException {
    final File localDirectory = cvsFileSystem.getAdminFileSystem().getFile(directoryObject);
    if (set) {
      final File cvsDirectory = getCvsDirectoryForLocalDirectory(localDirectory);
      if (cvsDirectory.exists()) {
        final File staticFile = new File(cvsDirectory, ENTRIES_STATIC_FILE_NAME);
        FileUtil.createIfDoesntExist(staticFile);
      }
    }
    else {
      final File entriesDotStaticFile = new File(getCvsDirectoryForLocalDirectory(localDirectory), ENTRIES_STATIC_FILE_NAME);
      if (entriesDotStaticFile.exists()) {
        FileUtil.delete(entriesDotStaticFile);
      }
    }
  }

  /**
   * Set the Entry in the specified directory.
   *
   * @throws IOException if an error occurs writing the details
   */
  public void setEntry(DirectoryObject directoryObject, Entry entry, ICvsFileSystem cvsFileSystem) throws IOException {
    BugLog.getInstance().assertNotNull(entry);

    final File directory = cvsFileSystem.getAdminFileSystem().getFile(directoryObject);

    myEntriesWriter.addEntry(directory, entry);
  }

  public void writeTemplateFile(DirectoryObject directoryObject,
                                int fileLength,
                                InputStream inputStream,
                                IReaderFactory readerFactory,
                                IClientEnvironment clientEnvironment) throws IOException {
    final FileObject fileObject = FileObject.createInstance(directoryObject, CVS_TEMPLATE_FILE_PATH);
    final IFileSystem adminFileSystem = clientEnvironment.getCvsFileSystem().getAdminFileSystem();
    if (fileLength == 0) {
      FileUtil.delete(adminFileSystem.getFile(fileObject));
      return;
    }

    clientEnvironment.getLocalFileWriter()
      .writeTextFile(fileObject, fileLength, inputStream, false, readerFactory, clientEnvironment.getFileReadOnlyHandler(), adminFileSystem,
                     null);
  }

  public void directoryAdded(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) throws IOException {
    final DirectoryObject parent = directoryObject.getParent();
    final String cvsRoot = getCvsRoot(parent, cvsFileSystem);
    final String repositoryPath = getRepository(parent, cvsFileSystem) + '/' + directoryObject.getName();
    final String stickyTag = AdminUtils.getStickyTagForDirectory(parent, cvsFileSystem);

    final File cvsDirectory = ensureCvsDirectory(directoryObject, cvsFileSystem);
    // now ensure that the Root and Repository files exist
    FileUtils.writeLine(new File(cvsDirectory, ROOT_FILE_NAME), cvsRoot);
    FileUtils.writeLine(new File(cvsDirectory, REPOSITORY_FILE_NAME), repositoryPath);
    new Entries().write(new File(cvsDirectory, ENTRIES_FILE_NAME), myLineSeparator, myCharset);
    setStickyTagForDirectory(directoryObject, stickyTag, cvsFileSystem);
    addDirectoryToParentEntriesFile(cvsDirectory.getParentFile());
  }

  // Utils ==================================================================

  private String getCvsRoot(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) throws IOException {
    final File cvsRootFile = cvsFileSystem.getAdminFileSystem().getFile(FileObject.createInstance(directoryObject, CVS_ROOT_FILE_PATH));
    return FileUtils.readLineFromFile(cvsRootFile);
  }

  private String getRepository(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) throws IOException {
    final File cvsRootFile =
      cvsFileSystem.getAdminFileSystem().getFile(FileObject.createInstance(directoryObject, CVS_REPOSITORY_FILE_PATH));
    return FileUtils.readLineFromFile(cvsRootFile);
  }

  private File getCvsDirectoryForLocalDirectory(File directory) {
    return new File(directory, CVS_DIR_NAME);
  }

  private void deleteDirectoryRecursively(File directory) {
    final File[] files = directory.listFiles();
    if (files == null) {
      return;
    }

    for (int i = 0; i < files.length; i++) {
      final File file = files[i];
      if (file.isDirectory()) {
        deleteDirectoryRecursively(file);
      }
      else {
        FileUtil.delete(file);
      }
    }
    FileUtil.delete(directory);
  }

  private File ensureCvsDirectory(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) {
    final File cvsDirectory = new File(cvsFileSystem.getAdminFileSystem().getFile(directoryObject), CVS_DIR_NAME);
    cvsDirectory.mkdirs();
    return cvsDirectory;
  }

  private void ensureExistingRootFile(File cvsDirectory, CvsRoot cvsRoot) throws IOException {
    final File rootFile = new File(cvsDirectory, ROOT_FILE_NAME);
    if (rootFile.exists()) {
      return;
    }

    FileUtils.writeLine(rootFile, cvsRoot.getCvsRoot());
  }

  private void ensureRepositoryFile(File cvsDirectory, String repositoryPath) throws IOException {
    final File repositoryFile = new File(cvsDirectory, REPOSITORY_FILE_NAME);
    if (repositoryFile.exists()) {
      return;
    }

    FileUtils.writeLine(repositoryFile, repositoryPath);
  }

  private void ensureExistingEntriesFile(File cvsDirectory) throws IOException {
    final File entriesFile = new File(cvsDirectory, ENTRIES_FILE_NAME);
    if (entriesFile.exists()) {
      return;
    }

    new Entries().write(entriesFile, myLineSeparator, myCharset);

    // need to know if we had to addEntry any directories so that we can
    // update the CVS/Entries file in the *parent* director
    addDirectoryToParentEntriesFile(cvsDirectory.getParentFile());
  }

  private void addDirectoryToParentEntriesFile(File directory) throws IOException {
    try {
      myEntriesWriter.addEntry(directory.getParentFile(), Entry.createDirectoryEntry(directory.getName()));
    }
    catch (FileNotFoundException ex) {
      // The Entries file will not exist in the case where this is the top level of the module
    }
  }

  private void createBaserevEntry(FileObject fileObject, ICvsFileSystem cvsFileSystem, Entry entry) throws IOException {
    if (entry == null || entry.getRevision() == null || entry.isAddedFile() || entry.isRemoved()) {
      throw new IllegalArgumentException("File does not have an Entry or Entry is invalid!");
    }

    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    final File baserevFile = new File(file.getParentFile(), CVS_BASEREV_FILE_PATH);
    final File backupFile = new File(baserevFile.getAbsolutePath() + '~');

    BufferedReader reader = null;
    BufferedWriter writer = null;
    boolean append = true;
    boolean writeFailed = true;
    final String entryStart = 'B' + file.getName() + '/';
    try {
      writer = new BufferedWriter(new FileWriter(backupFile));
      writeFailed = false;
      reader = new BufferedReader(new FileReader(baserevFile));

      for (String line = reader.readLine(); line != null; line = reader.readLine()) {

        if (line.startsWith(entryStart)) {
          append = false;
        }
        writeFailed = true;
        writer.write(line);
        writer.newLine();
        writeFailed = false;
      }
    }
    catch (IOException ex) {
      if (writeFailed) {
        throw ex;
      }
    }
    finally {
      if (reader != null) {
        try {
          reader.close();
        }
        catch (IOException ex) {
          // ignore
        }
      }
      if (writer != null) {
        if (append && !writeFailed) {
          writer.write(entryStart + entry.getRevision() + '/');
          writer.newLine();
        }

        try {
          writer.close();
        }
        catch (IOException ex) {
          // ignore
        }
      }
    }
    FileUtil.delete(baserevFile);
    FileUtil.rename(backupFile, baserevFile);
  }

  private void removeBaserevEntry(FileObject fileObject, ICvsFileSystem cvsFileSystem) throws IOException {
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    final File baserevFile = new File(file.getParentFile(), CVS_BASEREV_FILE_PATH);
    final File backupFile = new File(baserevFile.getAbsolutePath() + '~');

    BufferedReader reader = null;
    BufferedWriter writer = null;
    final String entryStart = 'B' + file.getName() + '/';
    try {
      writer = new BufferedWriter(new FileWriter(backupFile));
      reader = new BufferedReader(new FileReader(baserevFile));

      for (String line = reader.readLine(); line != null; line = reader.readLine()) {

        if (line.startsWith(entryStart)) {
          continue;
        }

        writer.write(line);
        writer.newLine();
      }
    }
    catch (FileNotFoundException ex) {
      // ignore
    }
    finally {
      if (writer != null) {
        try {
          writer.close();
        }
        catch (IOException ex) {
          // ignore
        }
      }
      if (reader != null) {
        try {
          reader.close();
        }
        catch (IOException ex) {
          // ignore
        }
      }
    }
    FileUtil.delete(baserevFile);
    if (backupFile.length() > 0) {
      FileUtil.rename(backupFile, baserevFile);
    }
    else {
      FileUtil.delete(backupFile);
    }
  }

  private File getEditBackupFile(FileObject fileObject, ICvsFileSystem cvsFileSystem) {
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    return new File(file.getParentFile(), CVS_BASE_FILE_PATH + file.getName());
  }

  private static class SimpleEntriesWriter implements EntriesWriter {
    private final String myCharset;
    private final String myLineSeparator;

    private SimpleEntriesWriter(final String charset, final String lineSeparator) {
      myCharset = charset;
      myLineSeparator = lineSeparator;
    }

    public void addEntry(final File directory, final Entry entry) throws IOException {
      final EntriesHandler entriesHandler = new EntriesHandler(directory);
      entriesHandler.read(myCharset);
      entriesHandler.getEntries().addEntry(entry);
      entriesHandler.write(myLineSeparator, myCharset);
    }
  }

}