Esempio n. 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;
   }
 }
Esempio n. 2
0
 /*
  * This method performs committing a deletion of a directory.
  */
 private static SVNCommitInfo deleteDir(ISVNEditor editor, String dirPath) 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);
   /*
    * Deletes the subdirectory with all its contents.
    *
    * dirPath is relative to the root directory.
    */
   editor.deleteEntry(dirPath, -1);
   /*
    * 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();
 }
Esempio n. 3
0
  public void close() throws SVNException {
    if (isFileOpened()) {
      editor.closeFile(pathsStack.pop(), null);
    }

    while (!pathsStack.empty()) {
      editor.closeDir();
      pathsStack.pop();
    }

    editor.closeDir();
    editor.closeEdit();
  }
  private SVNCommitInfo createSecondCommit() throws SVNException {
    String logMessage = "test second commit";
    ISVNWorkspaceMediator mediator = new PostCommitWorkspaceMediator();

    ISVNEditor editor = repository.getCommitEditor(logMessage, mediator);

    editor.openRoot(1);
    editor.addFile("dirB/file2.txt", null, -1);
    editor.applyTextDelta("dirB/file2.txt", null);

    OutputStream os = editor.textDeltaChunk("dirB/file2.txt", SVNDiffWindow.EMPTY);

    editor.textDeltaEnd("dirB/file2.txt");
    editor.closeFile("dirB/file2.txt", null);
    return editor.closeEdit();
  }
Esempio n. 5
0
  /*
   * This  method  performs how a directory in the repository can be copied to
   * branch.
   */
  private static SVNCommitInfo copyDir(
      ISVNEditor editor, String srcDirPath, String dstDirPath, long revision) 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);

    /*
     * Adds a new directory that is a copy of the existing one.
     *
     * srcDirPath   -  the  source  directory  path (relative  to  the  root
     * directory).
     *
     * dstDirPath - the destination directory path where the source will be
     * copied to (relative to the root directory).
     *
     * revision    - the number of the source directory revision.
     */
    editor.addDir(dstDirPath, srcDirPath, revision);
    /*
     * Closes the just added copy of 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();
  }
  /**
   * I take no credit for the below code. The creation of the svn repository is provided by the
   * svnkit library guys at: http://wiki.svnkit.com/Setting_Up_A_Subversion_Repository
   *
   * @throws SVNException
   */
  private SVNCommitInfo createSVNRepository() throws Exception {
    FSRepositoryFactory.setup();
    String repoDir = "/tmp/399165/svn";
    SVNRepositoryFactoryImpl.setup();
    SVNURL repo = SVNRepositoryFactory.createLocalRepository(new File("/tmp/399165"), true, true);
    repository = SVNRepositoryFactory.create(repo);
    String logMessage = "test commit message";

    ISVNWorkspaceMediator mediator = new PostCommitWorkspaceMediator();

    ISVNEditor editor = repository.getCommitEditor(logMessage, mediator);

    editor.openRoot(-1);
    editor.addDir("dirB", null, -1);
    editor.addFile("dirB/file1.txt", null, -1);
    editor.applyTextDelta("dirB/file1.txt", null);

    OutputStream os = editor.textDeltaChunk("dirB/file1.txt", SVNDiffWindow.EMPTY);

    editor.textDeltaEnd("dirB/file1.txt");
    editor.closeFile("dirB/file1.txt", null);
    return editor.closeEdit();
  }
Esempio n. 7
0
  /*
   * 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();
  }
Esempio n. 8
0
  /*
   * This method performs commiting an addition of a  directory  containing  a
   * file.
   */
  private static SVNCommitInfo addDir(
      ISVNEditor editor, String dirPath, String filePath, byte[] data) 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 (actually, for a comit  editor  this number  is
     * irrelevant)
     */
    editor.openRoot(-1);
    /*
     * Adds a new directory (in this  case - to the  root  directory  for
     * which the SVNRepository was  created).
     * Since this moment all changes will be applied to this new  directory.
     *
     * dirPath is relative to the root directory.
     *
     * copyFromPath (the 2nd parameter) is set to null and  copyFromRevision
     * (the 3rd) parameter is set to  -1  since  the  directory is not added
     * with history (is not copied, in other words).
     */
    editor.addDir(dirPath, null, -1);
    /*
     * Adds a new file to the just added  directory. The  file  path is also
     * defined as relative to the root directory.
     *
     * copyFromPath (the 2nd parameter) is set to null and  copyFromRevision
     * (the 3rd parameter) is set to -1 since  the file is  not  added  with
     * history.
     */
    editor.addFile(filePath, null, -1);
    /*
     * The next steps are directed to applying delta to the  file  (that  is
     * the full contents of the file in this case).
     */
    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, using 'base'
     * data will result 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(data), editor, true);

    /*
     * Closes the new added file.
     */
    editor.closeFile(filePath, checksum);
    /*
     * Closes the new added 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();
  }