1     public abstract void replay( long lowRevision , long revision , boolean sendDeltas , ISVNEditor editor ) throws SVNException;

   1     public long replicateRepository( SVNRepository src , SVNRepository dst , long fromRevision , long toRevision ) throws SVNException 

   1     public long replicateRepository( SVNRepository src , SVNRepository dst , boolean incremental ) throws SVNException 

   1     long fromRevision = incremental ? dst.getLatestRevision( ) + 1 : 1;
   2     return replicateRepository( src , dst , fromRevision , -1 );

   1     public void checkCancelled( ) throws SVNCancelException

   1     public void revisionReplicating( SVNRepositoryReplicator source , SVNLogEntry logEntry ) throws SVNException

   1     public void revisionReplicated( SVNRepositoryReplicator source , SVNCommitInfo commitInfo ) throws SVNException;

   1     private static void populateSourceRepository( SVNRepository srcRepository ) throws SVNException {
   2         /*
   3          * Simple repository tree to create. Each entry will be 
   4          * added in its own revision.
   5          */
   6         String dirA = "dirA";
   7         String dirB = "dirA/dirB";
   8         String fileA = "dirA/fileA.txt";
   9         String fileB = "dirA/dirB/fileB.txt";
  10         byte[] fileAContents = "This is file fileA.txt".getBytes( );
  11         byte[] fileBContents = "This is file fileB.txt".getBytes( );
  12         SVNDeltaGenerator deltaGenerator = new SVNDeltaGenerator( );
  13         long revision = -1;
  14         SVNCommitInfo info = null;
  15         String checksum = null;
  16         
  17         /*
  18          * First commit "/dirA".
  19          */
  20         ISVNEditor editor = srcRepository.getCommitEditor( "adding " + dirA , null );
  21         editor.openRoot( -1 );
  22         editor.addDir( dirA , null , -1 );
  23         editor.closeDir( );
  24         editor.closeDir( );
  25         info = editor.closeEdit( );
  26         System.out.println( info );
  27         revision = info.getNewRevision( );
  28         
  29         /*
  30          * Then commit "/dirA/fileA.txt".
  31          */
  32         editor = srcRepository.getCommitEditor( "adding " + fileA , null );
  33         editor.openRoot( -1 );
  34         editor.openDir( dirA , revision );
  35         editor.addFile( fileA , null , -1 );
  36         editor.applyTextDelta( fileA , null );
  37         checksum = deltaGenerator.sendDelta( fileA , new ByteArrayInputStream( fileAContents ) , editor , true );
  38         editor.closeFile( fileA , checksum );
  39         editor.closeDir( );
  40         editor.closeDir( );
  41         info = editor.closeEdit( );
  42         System.out.println( info );
  43         revision = info.getNewRevision( );
  44 
  45         /*
  46          * Then commit "/dirA/dirB".
  47          */
  48         editor = srcRepository.getCommitEditor( "adding " + dirB , null );
  49         editor.openRoot( -1 );
  50         editor.openDir( dirA , revision );
  51         editor.addDir( dirB , null , -1 );
  52         editor.closeDir( );
  53         editor.closeDir( );
  54         editor.closeDir( );
  55         info = editor.closeEdit( );
  56         System.out.println( info );
  57         revision = info.getNewRevision( );
  58         
  59         /*
  60          * Then commit "/dirA/dirB/fileB.txt".
  61          */
  62         editor = srcRepository.getCommitEditor( "adding " + fileB , null );
  63         editor.openRoot( -1 );
  64         editor.openDir( dirA , revision );
  65         editor.openDir( dirB , revision );
  66         editor.addFile( fileB , null , -1 );
  67         editor.applyTextDelta( fileB , null );
  68         checksum = deltaGenerator.sendDelta( fileB , new ByteArrayInputStream( fileBContents ) , editor , true );
  69         editor.closeFile( fileB , checksum );
  70         editor.closeDir( );
  71         editor.closeDir( );
  72         editor.closeDir( );
  73         info = editor.closeEdit( );
  74         System.out.println( info );
  75     }

   1 public class Replicate {
   2 
   3     public static void main( String[] args ) {
   4         /*
   5          * Default values:
   6          * source and target repository paths
   7          */
   8         String srcPath = "srcRepository";
   9         String tgtPath = "tgtRepository";
  10         String srcUrl = null;
  11         /*
  12          * Initializes the library (it must be done before ever using the
  13          * library itself)
  14          */
  15         setupLibrary( );
  16 
  17         if ( args != null ) {
  18             /*
  19              * a source repository url
  20              */
  21             srcUrl = ( args.length >= 1 ) ? args[0] : srcUrl;
  22             /*
  23              * a target repository path
  24              */
  25             tgtPath = ( args.length >= 2 ) ? args[1] : tgtPath;
  26         }
  27 
  28         SVNURL srcURL = null;
  29         SVNURL tgtURL = null;
  30         SVNRepository srcRepository = null;
  31         SVNRepository tgtRepository = null;
  32         boolean createSrcRepos = false;
  33         boolean populateSrcRepos = false;
  34         try {
  35             if ( srcUrl != null ) {
  36                 /*
  37                  * If a source url was provided, using it as a source repository
  38                  */
  39                 srcURL = SVNURL.parseURIDecoded( srcUrl );
  40                 if ( "file".equals( srcURL.getProtocol( ) ) ) {
  41                     File srcReposDir = new File( srcURL.getPath( ) );
  42                     if ( !srcReposDir.exists( ) ) {
  43                         /*
  44                          * it's a local access scheme and src path does not exist - 
  45                          * we'll need to create something
  46                          */
  47                         createSrcRepos = true;
  48                         populateSrcRepos = true;
  49                         srcPath = srcURL.getPath( );
  50                     } else {
  51                         srcRepository = SVNRepositoryFactory.create( srcURL );
  52                         if ( srcRepository.getLatestRevision( ) == 0 ) {
  53                             /*
  54                              * it's a local access scheme, src path already
  55                              * exists, but seems to be an empty repository - 
  56                              * we'll need to create something in it
  57                              */
  58                             populateSrcRepos = true;
  59                         }
  60                     }
  61                 }
  62             } else {
  63                 createSrcRepos = true;
  64                 populateSrcRepos = true;
  65             }
  66 
  67             if ( createSrcRepos ) {
  68                 srcURL = SVNRepositoryFactory.createLocalRepository( new File( srcPath ) , false , false );
  69             }
  70             
  71             /*
  72              * For the target repository we need to enable revision property 
  73              * changes. 
  74              */
  75             tgtURL = SVNRepositoryFactory.createLocalRepository(new File( tgtPath ) , true , false );
  76             
  77             srcRepository = SVNRepositoryFactory.create( srcURL );
  78             tgtRepository = SVNRepositoryFactory.create( tgtURL );
  79         } catch ( SVNException svne ) {
  80             /*
  81              * getFullMessage() will give us a full tree of SVNException 
  82              * errors.
  83              */
  84             System.err.println( "Can not create a repository: " + svne.getErrorMessage( ).getFullMessage( ) );
  85             System.exit( 1 );
  86         }
  87 
  88         /*
  89          * Deault auth manager is used to cache a username in the 
  90          * default Subversion credentials storage area.
  91          */
  92         srcRepository.setAuthenticationManager( SVNWCUtil.createDefaultAuthenticationManager( ) );
  93         tgtRepository.setAuthenticationManager( SVNWCUtil.createDefaultAuthenticationManager( ) );
  94         
  95         try{
  96             if ( populateSrcRepos ) {
  97                 /*
  98                  * Fills up the source repository with some data.
  99                  */
 100                 populateSourceRepository( srcRepository );
 101             }
 102             System.out.println( );
 103             long srcLatestRevision = srcRepository.getLatestRevision( );
 104             System.out.println( "The latest source revision: " + srcLatestRevision );
 105             System.out.println( );
 106             System.out.println( "'" + srcURL + "' repository tree:" );
 107             System.out.println( );
 108             /*
 109              * Using the DisplayRepositoryTree example to show the source 
 110              * repository tree in the latest revision. 
 111              */
 112             DisplayRepositoryTree.listEntries( srcRepository , "" );
 113             System.out.println( );
 114         } catch( SVNException svne ) {
 115             System.err.println( "An error occurred while accessing source repository: " + svne.getErrorMessage( ).getFullMessage( ) );
 116             System.exit( 1 );
 117         }
 118         ...

   1     private static void initializeRepository( SVNRepository fromRepos , SVNRepository toRepos ) throws SVNException {
   2         /*
   3          * Initialization means we need to set necessary svn:sync- properties
   4          * on revision 0 of the destination repository. But since our program
   5          * is just an example, we copy only revision properties from the 
   6          * source repository to the destination one.
   7          */
   8         copyRevisionProperties( fromRepos , toRepos , 0 );
   9     }

   1     private static void copyRevisionProperties( SVNRepository fromRepository , SVNRepository toRepository , long revision ) throws SVNException {
   2         Map revProps = fromRepository.getRevisionProperties( revision , null );
   3         for ( Iterator propNames = revProps.keySet( ).iterator( ); propNames.hasNext( ); ) {
   4             String propName = ( String ) propNames.next( );
   5             String propValue = ( String ) revProps.get( propName );
   6             toRepository.setRevisionPropertyValue( revision , propName , propValue );
   7         }
   8     }

   1     private static long synchronizeRepository( SVNRepository fromRepos , SVNRepository toRepos ) throws SVNException {
   2         long lastMergedRevision = 0;
   3         long fromLatestRevision = fromRepos.getLatestRevision( );
   4         long count = 0;
   5         for ( long currentRev = lastMergedRevision + 1 ; currentRev <= fromLatestRevision ; currentRev++ ) {
   6             ISVNEditor commitEditor = toRepos.getCommitEditor( "" , null );
   7             fromRepos.replay( 0 , currentRev , true , commitEditor );
   8             SVNCommitInfo info = commitEditor.closeEdit( );
   9                 
  10             if ( info.getNewRevision( ) != currentRev ) {
  11                 System.err.println( "Commit created rev " + info.getNewRevision( ) + " but should have created " + currentRev );
  12                 System.exit( 1 );
  13             }
  14             System.out.println( "Committed revision " + info.getNewRevision( ) );
  15             copyRevisionProperties( fromRepos , toRepos , currentRev );
  16             count++;
  17         }
  18         return count;
  19     }

   1     private static long replicateRepository( SVNRepository srcRepository , SVNRepository tgtRepository ) throws SVNException {
   2         long latestRevision = srcRepository.getLatestRevision( );
   3         SVNRepositoryReplicator replicator = SVNRepositoryReplicator.newInstance( );
   4         //use this handler to print out progress information on commits
   5         replicator.setReplicationHandler( new ISVNReplicationHandler( ) {
   6 
   7             public void revisionReplicated( SVNRepositoryReplicator source , SVNCommitInfo commitInfo ) throws SVNException {
   8                 System.out.println( "Committed revision " + commitInfo.getNewRevision( ) );
   9             }
  10             
  11             public void revisionReplicating( SVNRepositoryReplicator source , SVNLogEntry logEntry ) throws SVNException {
  12             }
  13             
  14             public void checkCancelled( ) throws SVNCancelException {
  15             }
  16         });
  17         
  18         return replicator.replicateRepository( srcRepository , tgtRepository , 1 , latestRevision );
  19     }

   1         ...
   2         
   3         try{
   4             /*
   5              * First let's try the standard replay way.
   6              */
   7             long replicatedRevisions = 0;
   8             try {
   9                 initializeRepository( srcRepository , tgtRepository );
  10                 replicatedRevisions = synchronizeRepository( srcRepository , tgtRepository );
  11             } catch ( SVNException svne ) {
  12                 if ( svne.getErrorMessage( ).getErrorCode( ) != SVNErrorCode.RA_NOT_IMPLEMENTED ) {
  13                     throw svne;
  14                 }
  15 
  16                 //...else the server does not support replay functionality
  17                 tgtRepository = SVNRepositoryFactory.create( tgtURL );
  18                 replicatedRevisions = replicateRepository( srcRepository , tgtRepository );
  19             }
  20             
  21             ...

   1          
   2             ...
   3             
   4             System.out.println( );
   5             System.out.println( "Number of replicated revisions: " + replicatedRevisions );
   6             System.out.println( );
   7             System.out.println( "'" + tgtURL + "' repository tree:" );
   8             System.out.println( );
   9             /*
  10              * Shows the tree of the target repository in the latest revision.
  11              */
  12             DisplayRepositoryTree.listEntries( tgtRepository , "" );
  13         }catch( SVNException svne ) {
  14             System.err.println( "An error occurred while accessing source repository: " + svne.getErrorMessage( ).getFullMessage( ) );
  15             System.exit( 1 );
  16         }
  17     }
  18 }