示例#1
0
 private SVNCommitInfo tryCommit(
     final String filePath, SVNRepository repository, final Map<String, String> locks)
     throws SVNException {
   ISVNEditor editor = repository.getCommitEditor("commit message", locks, true, null, null);
   try {
     editor.openRoot(-1);
     editor.openDir("Prueba", -1);
     editor.openDir("Prueba/Modify", -1);
     editor.openFile(filePath, -1);
     editor.applyTextDelta(filePath, null);
     final SVNDeltaGenerator generator = new SVNDeltaGenerator();
     final byte[] newContents = "new contents".getBytes();
     final String checksum =
         generator.sendDelta(filePath, new ByteArrayInputStream(newContents), editor, true);
     editor.closeFile(filePath, checksum);
     editor.closeDir();
     editor.closeDir();
     editor.closeDir();
     return editor.closeEdit();
   } catch (SVNException e) {
     if (editor != null) {
       editor.abortEdit();
     }
     throw e;
   }
 }
  /**
   * Accomodates the paths opened in editor to the given new path. This should be used only to open
   * existing directories.
   *
   * @param newPath
   * @param openLast
   * @param lastRevision
   * @throws SVNException
   */
  public void accomodate(String newPath, boolean openLast, long lastRevision) throws SVNException {
    // If there's a file opened, always closing it.
    if (fileOnTop) {
      // Checking if we don't want to have the same file opened.
      if (newPath.equals(pathsStack.peek())) return;

      editor.closeFile(pathsStack.pop(), null);
      fileOnTop = false;
    }

    // Poping and closing all opened directories which
    // don't fit into the new path.
    while ((!pathsStack.empty()) && (!newPath.startsWith(pathsStack.peek()))) {
      pathsStack.pop();
      editor.closeDir();
    }

    // Opening directories from the new path and putting their paths on the
    // stack.
    String currentPath = pathsStack.empty() ? "/" : pathsStack.peek();
    String[] parts = newPath.substring(currentPath.length()).split("[/]");
    for (int i = 0; i < (openLast ? parts.length : parts.length - 1); i++) {
      /*
       * A path part may be empty in two cases:
       * 1. pathStack.peek() is equal to newPath
       * 2. newPath = properPath + "/"
       * In both cases we don't want to open the "empty" directory.
       */
      if (!"".equals(parts[i])) {
        currentPath += Tools.addPaths(parts[i], "");
        editor.openDir(currentPath, lastRevision);
        pathsStack.push(currentPath);
      }
    }
  }
 public void copy(
     final ISVNEditor commitEditor,
     final String fromPath,
     final long fromRevision,
     final String toPath)
     throws SVNException {
   String dir = SVNPathUtil.removeTail(toPath);
   commitEditor.openDir(dir, -1);
   commitEditor.addFile(toPath, fromPath, fromRevision);
   commitEditor.closeDir();
 }
 public void moveDir(
     final ISVNEditor commitEditor,
     final String fromPath,
     final long baseRevision,
     final String toPath)
     throws SVNException {
   String dir = SVNPathUtil.removeTail(toPath);
   commitEditor.openDir(dir, -1);
   commitEditor.deleteEntry(fromPath, baseRevision);
   commitEditor.addDir(toPath, fromPath, baseRevision);
   commitEditor.closeDir();
 }
示例#5
0
文件: Commit.java 项目: hudson/svnkit
  /*
   * This method performs committing file modifications.
   */
  private static SVNCommitInfo modifyFile(
      ISVNEditor editor, String dirPath, String filePath, byte[] oldData, byte[] newData)
      throws SVNException {
    /*
     * Always called first. Opens the current root directory. It  means  all
     * modifications will be applied to this directory until  a  next  entry
     * (located inside the root) is opened/added.
     *
     * -1 - revision is HEAD
     */
    editor.openRoot(-1);
    /*
     * Opens a next subdirectory (in this example program it's the directory
     * added  in  the  last  commit).  Since this moment all changes will be
     * applied to this directory.
     *
     * dirPath is relative to the root directory.
     * -1 - revision is HEAD
     */
    editor.openDir(dirPath, -1);
    /*
     * Opens the file added in the previous commit.
     *
     * filePath is also defined as a relative path to the root directory.
     */
    editor.openFile(filePath, -1);

    /*
     * The next steps are directed to applying and writing the file delta.
     */
    editor.applyTextDelta(filePath, null);

    /*
     * Use delta generator utility class to generate and send delta
     *
     * Note that you may use only 'target' data to generate delta when there is no
     * access to the 'base' (previous) version of the file. However, here we've got 'base'
     * data, what in case of larger files results in smaller network overhead.
     *
     * SVNDeltaGenerator will call editor.textDeltaChunk(...) method for each generated
     * "diff window" and then editor.textDeltaEnd(...) in the end of delta transmission.
     * Number of diff windows depends on the file size.
     *
     */
    SVNDeltaGenerator deltaGenerator = new SVNDeltaGenerator();
    String checksum =
        deltaGenerator.sendDelta(
            filePath,
            new ByteArrayInputStream(oldData),
            0,
            new ByteArrayInputStream(newData),
            editor,
            true);

    /*
     * Closes the file.
     */
    editor.closeFile(filePath, checksum);

    /*
     * Closes the directory.
     */
    editor.closeDir();

    /*
     * Closes the root directory.
     */
    editor.closeDir();

    /*
     * This is the final point in all editor handling. Only now all that new
     * information previously described with the editor's methods is sent to
     * the server for committing. As a result the server sends the new
     * commit information.
     */
    return editor.closeEdit();
  }