Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   *                 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.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.

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(s):
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 lineSeparatorfinal String charsetfinal EntriesWriter creator) {
      = lineSeparator;
      = charset;
      = creator;
   }
 
   public AdminWriter(String lineSeparatorfinal String charset) {
     this(lineSeparatorcharsetnew SimpleEntriesWriter(charsetlineSeparator));
   }
 
   // Implemented ============================================================
 
   public void ensureCvsDirectory(DirectoryObject directoryObjectString repositoryPath, CvsRoot cvsRoot, ICvsFileSystem cvsFileSystem)
     throws IOException {
     final File cvsDirectory = ensureCvsDirectory(directoryObjectcvsFileSystem);
     // now ensure that the Root and Repository files exist
     ensureExistingRootFile(cvsDirectorycvsRoot);
     ensureRepositoryFile(cvsDirectory ? cvsFileSystem.getRelativeRepositoryPath(repositoryPath) : repositoryPath);
     ensureExistingEntriesFile(cvsDirectory);
   }
 
   public void removeEntryForFile(AbstractFileObject fileObject, ICvsFileSystem cvsFileSystemthrows 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();
     final boolean entryRemoved = entriesHandler.getEntries().removeEntry(file.getName());
     if (entriesUpdated || entryRemoved) {
       entriesHandler.write();
     }
   }
 
   public void pruneDirectory(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystem) {
     deleteDirectoryRecursively(cvsFileSystem.getLocalFileSystem().getFile(directoryObject));
     deleteDirectoryRecursively(cvsFileSystem.getAdminFileSystem().getFile(directoryObject));
   }
 
   public void setStickyTagForDirectory(DirectoryObject directoryObjectString tag, ICvsFileSystem cvsFileSystemthrows IOException {
    final File cvsDirectory = new File(cvsFileSystem.getAdminFileSystem().getFile(directoryObject), );
    if (!cvsDirectory.isDirectory()) {
      return;
    }
    final File tagFile = new File(cvsDirectory);
    if (tag != null) {
      FileUtils.writeLine(tagFiletag);
    }
    else {
      FileUtil.delete(tagFile);
    }
  }
  public void editFile(FileObject fileObject, Entry entry, ICvsFileSystem cvsFileSystem, IFileReadOnlyHandler fileReadOnlyHandler)
    throws IOException {
    createBaserevEntry(fileObjectcvsFileSystementry);
    final File localFile = cvsFileSystem.getLocalFileSystem().getFile(fileObject);
    FileUtils.copyFile(localFilegetEditBackupFile(fileObjectcvsFileSystem));
    fileReadOnlyHandler.setFileReadOnly(localFilefalse);
  }
  public void uneditFile(FileObject fileObject, ICvsFileSystem cvsFileSystem, IFileReadOnlyHandler fileReadOnlyHandlerthrows IOException {
    final File editBackupFile = getEditBackupFile(fileObjectcvsFileSystem);
    if (!editBackupFile.isFile()) {
      return;
    }
    FileUtil.delete(editBackupFile);
    removeBaserevEntry(fileObjectcvsFileSystem);
    fileReadOnlyHandler.setFileReadOnly(cvsFileSystem.getLocalFileSystem().getFile(fileObject), true);
  }
  public void setEntriesDotStatic(DirectoryObject directoryObjectboolean set, ICvsFileSystem cvsFileSystemthrows IOException {
    final File localDirectory = cvsFileSystem.getAdminFileSystem().getFile(directoryObject);
    if (set) {
      final File cvsDirectory = getCvsDirectoryForLocalDirectory(localDirectory);
      if (cvsDirectory.exists()) {
        final File staticFile = new File(cvsDirectory);
        FileUtil.createIfDoesntExist(staticFile);
      }
    }
    else {
      final File entriesDotStaticFile = new File(getCvsDirectoryForLocalDirectory(localDirectory), );
      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 cvsFileSystemthrows IOException {
    BugLog.getInstance().assertNotNull(entry);
    final File directory = cvsFileSystem.getAdminFileSystem().getFile(directoryObject);
    .addEntry(directoryentry);
  }
  public void writeTemplateFile(DirectoryObject directoryObject,
                                int fileLength,
                                InputStream inputStream,
                                IReaderFactory readerFactory,
                                IClientEnvironment clientEnvironmentthrows IOException {
    final FileObject fileObject = FileObject.createInstance(directoryObject);
    final IFileSystem adminFileSystem = clientEnvironment.getCvsFileSystem().getAdminFileSystem();
    if (fileLength == 0) {
      FileUtil.delete(adminFileSystem.getFile(fileObject));
      return;
    }
    clientEnvironment.getLocalFileWriter()
      .writeTextFile(fileObjectfileLengthinputStreamfalsereaderFactoryclientEnvironment.getFileReadOnlyHandler(), adminFileSystem,
                     null);
  }
  public void directoryAdded(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystemthrows IOException {
    final DirectoryObject parent = directoryObject.getParent();
    final String cvsRoot = getCvsRoot(parentcvsFileSystem);
    final String repositoryPath = getRepository(parentcvsFileSystem) + '/' + directoryObject.getName();
    final String stickyTag = AdminUtils.getStickyTagForDirectory(parentcvsFileSystem);
    final File cvsDirectory = ensureCvsDirectory(directoryObjectcvsFileSystem);
    // now ensure that the Root and Repository files exist
    FileUtils.writeLine(new File(cvsDirectory), cvsRoot);
    FileUtils.writeLine(new File(cvsDirectory), repositoryPath);
    new Entries().write(new File(cvsDirectory), );
    setStickyTagForDirectory(directoryObjectstickyTagcvsFileSystem);
  }
  // Utils ==================================================================
  private String getCvsRoot(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystemthrows IOException {
    final File cvsRootFile = cvsFileSystem.getAdminFileSystem().getFile(FileObject.createInstance(directoryObject));
    return FileUtils.readLineFromFile(cvsRootFile);
  }
  private String getRepository(DirectoryObject directoryObject, ICvsFileSystem cvsFileSystemthrows IOException {
    final File cvsRootFile =
      cvsFileSystem.getAdminFileSystem().getFile(FileObject.createInstance(directoryObject));
    return FileUtils.readLineFromFile(cvsRootFile);
  }
  private File getCvsDirectoryForLocalDirectory(File directory) {
    return new File(directory);
  }
  private void deleteDirectoryRecursively(File directory) {
    final File[] files = directory.listFiles();
    if (files == null) {
      return;
    }
    for (int i = 0; i < files.lengthi++) {
      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), );
    cvsDirectory.mkdirs();
    return cvsDirectory;
  }
  private void ensureExistingRootFile(File cvsDirectory, CvsRoot cvsRootthrows IOException {
    final File rootFile = new File(cvsDirectory);
    if (rootFile.exists()) {
      return;
    }
    FileUtils.writeLine(rootFilecvsRoot.getCvsRoot());
  }
  private void ensureRepositoryFile(File cvsDirectoryString repositoryPaththrows IOException {
    final File repositoryFile = new File(cvsDirectory);
    if (repositoryFile.exists()) {
      return;
    }
    FileUtils.writeLine(repositoryFilerepositoryPath);
  }
  private void ensureExistingEntriesFile(File cvsDirectorythrows IOException {
    final File entriesFile = new File(cvsDirectory);
    if (entriesFile.exists()) {
      return;
    }
    new Entries().write(entriesFile);
    // need to know if we had to addEntry any directories so that we can
    // update the CVS/Entries file in the *parent* director
  }
  private void addDirectoryToParentEntriesFile(File directorythrows IOException {
    try {
      .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 entrythrows 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(), );
    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 != nullline = 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(backupFilebaserevFile);
  }
  private void removeBaserevEntry(FileObject fileObject, ICvsFileSystem cvsFileSystemthrows IOException {
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    final File baserevFile = new File(file.getParentFile(), );
    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 != nullline = 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(backupFilebaserevFile);
    }
    else {
      FileUtil.delete(backupFile);
    }
  }
  private File getEditBackupFile(FileObject fileObject, ICvsFileSystem cvsFileSystem) {
    final File file = cvsFileSystem.getAdminFileSystem().getFile(fileObject);
    return new File(file.getParentFile(),  + file.getName());
  }
  private static class SimpleEntriesWriter implements EntriesWriter {
    private final String myCharset;
    private final String myLineSeparator;
    private SimpleEntriesWriter(final String charsetfinal String lineSeparator) {
       = charset;
       = lineSeparator;
    }
    public void addEntry(final File directoryfinal Entry entrythrows IOException {
      final EntriesHandler entriesHandler = new EntriesHandler(directory);
      entriesHandler.read();
      entriesHandler.getEntries().addEntry(entry);
      entriesHandler.write();
    }
  }
New to GrepCode? Check out our FAQ X