Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * ====================================================================
   * Copyright (c) 2004-2006 TMate Software Ltd.  All rights reserved.
   *
   * This software is licensed as described in the file COPYING, which
   * you should have received as part of this distribution.  The terms
   * are also available at http://svnkit.com/license.html
   * If newer versions of this license are posted there, you may use a
   * newer version instead, at your option.
  * ====================================================================
  */
 package org.tmatesoft.svn.core.replicator;
 
 import java.util.List;
 import java.util.Map;
 
The SVNReplicationEditor is an editor implementation used by a repository replicator as a bridge between an update editor for the source repository and a commit editor of the target one. This editor is provided to an update method of a source SVNRepository driver to properly translate the calls of that driver to calls to a commit editor of the destination SVNRepository driver.

Author(s):
TMate Software Ltd.
Version:
1.1.0
Since:
1.1
See also:
org.tmatesoft.svn.core.io.SVNRepository
 
 public class SVNReplicationEditor implements ISVNEditor {
 
     private static final int ACCEPT = 0;
     private static final int IGNORE = 1;
     private static final int DECIDE = 2;
 
     private ISVNEditor myCommitEditor;
     private Map myCopiedPaths;
     private Map myChangedPaths;
     private SVNRepository myRepos;
     private Map myPathsToFileBatons;
     private Stack myDirsStack;
     private long myPreviousRevision;
     private long myTargetRevision;
     private SVNCommitInfo myCommitInfo;
     private SVNRepository mySourceRepository;
    
    
Creates a new replication editor.

repository must be created for the root location of the source repository which is to be replicated.

Parameters:
repository a source repository
commitEditor a commit editor received from the destination repository driver (which also must be point to the root location of the destination repository)
revision log information of the revision to be copied
 
     public SVNReplicationEditor(SVNRepository repositoryISVNEditor commitEditorSVNLogEntry revision) {
          = repository;
          = commitEditor;
          = new HashMap();
          = new Stack();
          = new HashMap();
          = revision.getChangedPaths();
 
         for(Iterator paths = .keySet().iterator(); paths.hasNext();){
             String path = (String)paths.next();
             SVNLogEntryPath pathChange = (SVNLogEntryPath).get(path);
             //make sure it's a copy
             if((pathChange.getType() == . || pathChange.getType() == .) && pathChange.getCopyPath() != null && pathChange.getCopyRevision() >= 0){
                 .put(pathpathChange);
             }
         }
    }
    public void targetRevision(long revisionthrows SVNException {
         = revision - 1;
         = revision;
    }
    public void openRoot(long revisionthrows SVNException {
        //open root
        EntryBaton baton = new EntryBaton("/");
        baton.myPropsAct = ;
        .push(baton);
    }
    public void deleteEntry(String pathlong revisionthrows SVNException {
        String absPath = getSourceRepository().getRepositoryPath(path);
        SVNLogEntryPath deletedPath = (SVNLogEntryPath.get(absPath);
        if (deletedPath != null && 
                (deletedPath.getType() == . || deletedPath.getType() == .)) {
            if (deletedPath.getType() == .) {
                .remove(absPath);
            }
        } else {
            SVNErrorMessage err = SVNErrorMessage.create(."Expected that path ''{0}'' is deleted in revision {1,number,integer}"new Object[]{absPathnew Long()});
            SVNErrorManager.error(err);
        }
    }
    public void absentDir(String paththrows SVNException {
    }
    public void absentFile(String paththrows SVNException {
    }
    public void addDir(String pathString copyFromPathlong copyFromRevisionthrows SVNException {
        String absPath = getSourceRepository().getRepositoryPath(path);
        EntryBaton baton = new EntryBaton(absPath);
        .push(baton);
        SVNLogEntryPath changedPath = (SVNLogEntryPath.get(absPath);
        if (changedPath != null && (changedPath.getType() == . || changedPath.getType() == .) && changedPath.getCopyPath() != null && changedPath.getCopyRevision() >= 0) {
            baton.myPropsAct = ;
            HashMap props = new HashMap();
            getSourceRepository().getDir(changedPath.getCopyPath(), changedPath.getCopyRevision(), props, (ISVNDirEntryHandlernull);
            baton.myProps = props;
            
            if (changedPath.getType() == .) {
                .deleteEntry(path);
                .remove(absPath);
            }
            .addDir(pathchangedPath.getCopyPath(), changedPath.getCopyRevision());
        } else if (changedPath != null && (changedPath.getType() == . || changedPath.getType() == .)) {
            baton.myPropsAct = ;
            .addDir(pathnull, -1);
        } else if (changedPath != null && changedPath.getType() == .) {
            baton.myPropsAct = ;
            .openDir(path);
        } else if (changedPath == null) {
            baton.myPropsAct = ;
            .openDir(path);
        } else {
            SVNErrorMessage err = SVNErrorMessage.create(."Unknown bug in addDir()");
            SVNErrorManager.error(err);
        }
    }
    public void openDir(String pathlong revisionthrows SVNException {
        EntryBaton baton = new EntryBaton(getSourceRepository().getRepositoryPath(path));
        baton.myPropsAct = ;
        .push(baton);
    }
    public void changeDirProperty(String nameString valuethrows SVNException {
        if (!SVNProperty.isRegularProperty(name)) {
            return;
        }
        EntryBaton baton = (EntryBaton.peek();
        if (baton.myPropsAct == ) {
            .changeDirProperty(namevalue);
        } else if (baton.myPropsAct == ) {
            String propVal = (String)baton.myProps.get(name);
            if (propVal != null && propVal.equals(value)) {
                /*
                 * The properties seem to be the same as of the copy origin,
                 * do not reset them again.
                 */
                baton.myPropsAct = ;
                return;
            }
            /*
             * Properties do differ, accept them.
             */
            baton.myPropsAct = ;
            .changeDirProperty(namevalue);
        }
    }
    public void closeDir() throws SVNException {
        if (.size() > 1 && !.isEmpty()) {
            EntryBaton currentDir = (EntryBaton.peek();
            completeDeletion(currentDir.myPath);
        }
        .pop();
        .closeDir();
    }
    public void addFile(String pathString copyFromPathlong copyFromRevisionthrows SVNException {
        String absPath = getSourceRepository().getRepositoryPath(path);
        EntryBaton baton = new EntryBaton(absPath);
        .put(pathbaton);
        SVNLogEntryPath changedPath = (SVNLogEntryPath.get(absPath);
        
        if (changedPath != null && (changedPath.getType() == . || changedPath.getType() == .) && changedPath.getCopyPath() != null && changedPath.getCopyRevision() >= 0) {
            baton.myPropsAct = ;
            baton.myTextAct = ;
            Map props = new HashMap();
            if (areFileContentsEqual(absPathchangedPath.getCopyPath(), changedPath.getCopyRevision(), props)) {
                baton.myTextAct = ;
            }
            baton.myProps = props;
            if(changedPath.getType() == .){
                .deleteEntry(path);
                .remove(absPath);
            }
            .addFile(pathchangedPath.getCopyPath(), changedPath.getCopyRevision());
        } else if (changedPath != null && (changedPath.getType() == . || changedPath.getType() == .)) {
            baton.myPropsAct = ;
            baton.myTextAct = ;
            if(changedPath.getType() == .){
                .deleteEntry(path);
                .remove(absPath);
            }
            .addFile(pathnull, -1);
        } else if (changedPath != null && changedPath.getType() == .) {
            baton.myPropsAct = ;
            baton.myTextAct = ;
            SVNLogEntryPath realPath = getFileCopyOrigin(absPath);
            if (realPath == null) {
                SVNErrorMessage err = SVNErrorMessage.create(."Unknown error, can't get the copy origin of a file");
                SVNErrorManager.error(err);
            }
            Map props = new HashMap();
            if (areFileContentsEqual(absPathrealPath.getCopyPath(), realPath.getCopyRevision(), props)) {
                baton.myTextAct = ;
            }
            baton.myProps = props;
            .openFile(path);
        } else if (changedPath == null) {
            baton.myPropsAct = ;
            baton.myTextAct = ;
        } else {
            SVNErrorMessage err = SVNErrorMessage.create(."Unknown bug in addFile()");
            SVNErrorManager.error(err);
        }
    }
    private SVNLogEntryPath getFileCopyOrigin(String paththrows SVNException {
        Object[] paths = .keySet().toArray();
        Arrays.sort(paths, 0, paths.length.);
        SVNLogEntryPath realPath = null;
        List candidates = new ArrayList();
        for (int i = 0; i < paths.lengthi++) {
            String copiedPath = (Stringpaths[i];
            
            if (!path.startsWith(copiedPath + "/")) {
                continue;
            } else if (path.equals(copiedPath)) {
                return (SVNLogEntryPath.get(copiedPath);
            }
            candidates.add(copiedPath);
        }
        // check candidates from the end of the list
        for(int i = candidates.size() - 1; i >=0; i--) {
            String candidateParent = (Stringcandidates.get(i);
            if (getSourceRepository().checkPath(candidateParent) != .) {
                continue;
            }
            SVNLogEntryPath changedPath = (SVNLogEntryPath.get(candidateParent);
            String fileRelativePath = path.substring(candidateParent.length() + 1);
            fileRelativePath = SVNPathUtil.append(changedPath.getCopyPath(), fileRelativePath);
            return new SVNLogEntryPath(path' 'fileRelativePathchangedPath.getCopyRevision());
        }
        return realPath;
    }
    private boolean areFileContentsEqual(String path1long rev1String path2long rev2Map props2throws SVNException {
        Map props1 = new HashMap();
        props2 = props2 == null ? new HashMap() : props2;
        SVNRepository repos = getSourceRepository();
        repos.getFile(path1rev1props1null);
        repos.getFile(path2rev2props2null);
        String crc1 = (Stringprops1.get(.);
        String crc2 = (Stringprops2.get(.);
        return crc1 != null && crc1.equals(crc2);
    }
    public void openFile(String pathlong revisionthrows SVNException {
        EntryBaton baton = new EntryBaton(getSourceRepository().getRepositoryPath(path));
        baton.myPropsAct = ;
        baton.myTextAct = ;
        .put(pathbaton);
    }
    public void applyTextDelta(String pathString baseChecksumthrows SVNException {
        EntryBaton baton = (EntryBaton.get(path);
        if (baton.myTextAct == ) {
            .applyTextDelta(pathbaseChecksum);
        }
    }
    public OutputStream textDeltaChunk(String pathSVNDiffWindow diffWindowthrows SVNException {
        EntryBaton baton = (EntryBaton.get(path);
        if (baton.myTextAct == ) {
            return .textDeltaChunk(pathdiffWindow);
        }
        return .;
    }
    public void textDeltaEnd(String paththrows SVNException {
        EntryBaton baton = (EntryBaton.get(path);
        if (baton.myTextAct == ) {
            .textDeltaEnd(path);
        }
    }
    public void changeFileProperty(String pathString nameString valuethrows SVNException {
        if (!SVNProperty.isRegularProperty(name)) {
            return;
        }
        EntryBaton baton = (EntryBaton.get(path);
        if (baton.myPropsAct == ) {
            .changeFileProperty(pathnamevalue);
        } else if (baton.myPropsAct == ) {
            String propVal = (String)baton.myProps.get(name);
            if (propVal != null && propVal.equals(value)) {
                /*
                 * The properties seem to be the same as of the copy origin,
                 * do not reset them again.
                 */
                baton.myPropsAct = ;
                return;
            }
            /*
             * Properties do differ, accept them.
             */
            baton.myPropsAct = ;
            .changeFileProperty(pathnamevalue);
        }
    }
    public void closeFile(String pathString textChecksumthrows SVNException {
        EntryBaton baton = (EntryBaton.get(path);
        if (baton.myTextAct !=  || baton.myTextAct != ) {
            .closeFile(pathtextChecksum);
        }
    }
    public SVNCommitInfo closeEdit() throws SVNException {
        return ;
        
    }
    public void abortEdit() throws SVNException {
        .abortEdit();
    }
    
    
Returns commit information on the revision committed to the replication destination repository.

Returns:
commit info (revision, author, date)
    public SVNCommitInfo getCommitInfo() {
        return ;
    }
    
    private SVNRepository getSourceRepository() throws SVNException {
        if ( == null) {
             = SVNRepositoryFactory.create(.getLocation());
        }
        return ;
    }
    
    private void completeDeletion(String dirPaththrows SVNException {
        Collection pathsToDelete = new ArrayList();
        for(Iterator paths = .keySet().iterator(); paths.hasNext();){
            String path = (String)paths.next();
            if (!path.startsWith(dirPath + "/")) {
                continue;
            }
            SVNLogEntryPath pathChange = (SVNLogEntryPath).get(path);
            if(pathChange.getType() == .){
                String relativePath = path.substring(dirPath.length() + 1);
                pathsToDelete.add(relativePath);
            }
        }
        String[] pathsArray = (String[]) pathsToDelete.toArray(new String[pathsToDelete.size()]);
        Arrays.sort(pathsArray.);
        String currentOpened = "";
        for(int i = 0; i < pathsArray.lengthi++) {
            String nextRelativePath = pathsArray[i];
            while(!"".equals(currentOpened) && nextRelativePath.indexOf(currentOpened) == -1){
                .closeDir();
                currentOpened = SVNPathUtil.removeTail(currentOpened);
            }
            
            String nextRelativePathToDelete = null;
            if(!"".equals(currentOpened)){
                nextRelativePathToDelete = nextRelativePath.substring(currentOpened.length() + 1);
            }else{
                nextRelativePathToDelete = nextRelativePath;
            }
            String[] entries = nextRelativePathToDelete.split("/");
            int j = 0;
            for(j = 0; j < entries.length - 1; j++){
                currentOpened = SVNPathUtil.append(currentOpenedentries[j]);
                .openDir(SVNPathUtil.append(dirPathcurrentOpened), );
            }
            String pathToDelete = SVNPathUtil.append(currentOpenedentries[j]);
            String absPathToDelete = SVNPathUtil.append(dirPathpathToDelete);
            .deleteEntry(absPathToDelete);
            .remove(absPathToDelete);
        }
        while(!"".equals(currentOpened)){
            .closeDir();
            currentOpened = SVNPathUtil.removeTail(currentOpened);
        }
    }
    private static class EntryBaton {
        
        public EntryBaton(String path) {
             = path;
        }
        private String myPath;
        private int myPropsAct;
        private int myTextAct;
        private Map myProps;
    }
New to GrepCode? Check out our FAQ X