1     ...
   2     FSRepositoryFactory.setup( );
   3     String url = "file://localhost/rep/nodeA/";
   4 
   5     SVNRepository repository = SVNRepositoryFactory.create( SVNURL.parseURIDecoded( url ) );
   6     ReporterBaton reporterBaton = ...;
   7     ISVNEditor editor = ...;
   8     
   9     repository.update( -1 /*forces to use the latest revision*/ , null /*target*/ , true /*recursive*/ , reporterBaton , editor );
  10     ...

   1 ...
   2 public class ReporterBaton implements ISVNReporterBaton {
   3 
   4     ...
   5     
   6     public void report( ISVNReporter reporter ) throws SVNException {
   7         
   8         //for the WC root
   9         reporter.setPath( "" /*path*/ , null /*lockToken*/ , 4 /*revision*/ , false /*startEmpty*/ );
  10 
  11         ...

   1     repository.update( -1 /*revision*/ , "itemA1" /*target*/ , false /*recursive*/ , reporterBaton , editor );

   1         ...
   2 
   3         reporter.setPath( "nodeB" , null , 5 , false );
   4 
   5         ...

   1         ...
   2 
   3         //provide the item's lock token
   4         String lockToken = ...;
   5         reporter.setPath( "itemA2" , lockToken , 4 , false );
   6 
   7         ...

   1         ...
   2 
   3         SVNURL url = SVNURL.parseURIDecoded( "file://localhost/rep/node2A/nodeC/nodeD/" );
   4         //switched paths are described in this way:
   5         reporter.linkPath( url , "nodeC/nodeD" , null /*lockToken*/ , 4 /*revision*/ , false /*startEmpty*/ );
   6 
   7         ...

   1         ...
   2         reporter.deletePath( "nodeF" );
   3         reporter.deletePath( "nodeG" );
   4         reporter.deletePath( "nodeL" );
   5         ...

   1         ...
   2 
   3         reporter.setPath( "nodeH" , null , 4 , true /*startEmpty*/ );
   4         reporter.setPath( "nodeH/nodeH2" , null , 4 , false /*startEmpty*/ );
   5         reporter.setPath( "nodeH/itemH" , null , 5 , false /*startEmpty*/ );
   6 
   7         ...

   1         long rev = ...;
   2         reporter.setPath( "" , null , rev , true );

   1         ...
   2         
   3         //called at the end of a report
   4         reporter.finishReport( );
   5         
   6         ...
   7     }
   8 }

   1         ...
   2         
   3         try {
   4             ...        
   5             reporter.setPath( ... );
   6             ...
   7         } catch( SVNException svne ) {
   8             reporter.abortReport( );
   9             ...
  10         }
  11         
  12         ...

   1     ...
   2 
   3     ISVNReporter reporter = ...;
   4     reporterBaton.report( reporter );
   5 
   6     ...

   1     ...
   2     //let HEAD revision be 7
   3     editor.targetRevision( 7 );
   4 
   5     //gives the source revision we provided in our report
   6     editor.openRoot( 4 );
   7 
   8     //in revision 7 properties were added for nodeB
   9     editor.openDir( "nodeB" , 5 );
  10     editor.changeDirProperty( "prop1" , "val1" );
  11     editor.changeDirProperty( "prop2" , "val2" );
  12     editor.closeDir( );
  13 
  14     ...
  15     
  16     //receiving changes for a switched node - nodeD
  17     editor.openDir( "nodeC" , 4 );
  18     editor.openDir( "nodeC/nodeD" , 4 );
  19     //itemD2 was added under /node2A/nodeC/nodeD/ in the repository
  20     editor.addFile( "nodeC/nodeD/itemD2" , null , -1 );
  21     editor.applyTextDelta( "nodeC/nodeD/itemD2" , null );
  22     editor.textDeltaChunk( "nodeC/nodeD/itemD2" , window1 );
  23     ...
  24     editor.textDeltaEnd( "nodeC/nodeD/itemD2" );
  25     //text checksum
  26     editor.closeFile( "nodeC/nodeD/itemD2" , checksum );
  27     //closing nodeC/nodeD
  28     editor.closeDir( );
  29     //closing nodeC
  30     editor.closeDir( );
  31 
  32     ...
  33     
  34     //we are still not permitted to read /nodeA/nodeF,
  35     //this is how a server lets us know about this
  36     editor.absentDir( "nodeF" );
  37     
  38     ...

   1     editor.openDir( "nodeH" , 4 );
   2     editor.addDir( "nodeH/nodeH2" , null , -1 );
   3     //closing nodeH/nodeH2
   4     editor.closeDir( );
   5 
   6     editor.addDir( "nodeH/nodeH3" , null , -1 );
   7     //closing nodeH/nodeH3
   8     editor.closeDir( );
   9 
  10     editor.addFile( "nodeH/itemH2" , null , -1 );
  11     editor.applyTextDelta( "nodeH/itemH2" , null );
  12     //sending delta windows
  13     ...
  14     editor.textDeltaEnd( "nodeH/itemH2" );
  15     editor.closeFile( "nodeH/itemH2" , checksum );
  16 
  17     //receiving changes for nodeH/itemH
  18     editor.openFile( "nodeH/itemH" , 5 );
  19     editor.applyTextDelta( "nodeH/itemH" , baseChecksum );
  20     //sending delta windows
  21     ...
  22     editor.textDeltaEnd( "nodeH/itemH" );
  23     editor.closeFile( "nodeH/itemH" , checksum );
  24     //closing nodeH
  25     editor.closeDir( );
  26     ...
  27     
  28     //the lock on itemA2 was broken in the repository
  29     editor.changeFileProperty( "itemA2" , SVNProperty.LOCK_TOKEN , null );
  30     
  31     ...
  32     
  33     //receiving a missing node - /nodeA/nodeL
  34     editor.addDir( "nodeL" , null , -1 );
  35     ...
  36     editor.closeDir( );
  37     
  38     ...

   1     ...
   2     
   3     //closes the WC root
   4     editor.closeDir( );
   5     //finishes editing
   6     ediotr.closeEdit( );
   7     
   8     ...

   1 public class ExportReporterBaton implements ISVNReporterBaton {
   2 
   3     private long exportRevision;
   4         
   5     public ExportReporterBaton( long revision ){
   6         exportRevision = revision;
   7     }
   8         
   9     public void report( ISVNReporter reporter ) throws SVNException {
  10         try {
  11             reporter.setPath( "" , null , exportRevision , true );
  12             reporter.finishReport( );
  13         } catch( SVNException svne ) {
  14             reporter.abortReport( );
  15             System.out.println( "Report failed" );
  16         }
  17     }
  18 }

   1 public class ExportEditor implements ISVNEditor {
   2         
   3     private File myRootDirectory;
   4     private SVNDeltaProcessor myDeltaProcessor;
   5         
   6     public ExportEditor( File root ) {
   7         myRootDirectory = root;
   8 
   9         /*
  10          * Utility class that will help us to transform 'deltas' sent by the 
  11          * server to the new file contents.  
  12          */
  13         myDeltaProcessor = new SVNDeltaProcessor( );
  14     }
  15 
  16     public void targetRevision( long revision ) throws SVNException {
  17     }
  18 
  19     public void openRoot( long revision ) throws SVNException {
  20     }
  21         
  22     public void addDir( String path , String copyFromPath , long copyFromRevision ) throws SVNException {
  23         File newDir = new File( myRootDirectory , path );
  24         if ( !newDir.exists( ) ) {
  25             if ( !newDir.mkdirs( ) ) {
  26                 SVNErrorMessage err = SVNErrorMessage.create( SVNErrorCode.IO_ERROR , "error: failed to add the directory ''{0}''." , newDir );
  27                 throw new SVNException( err );
  28             }
  29         }
  30         System.out.println( "dir added: " + path );
  31     }
  32         
  33     public void openDir( String path , long revision ) throws SVNException {
  34     }
  35 
  36     public void changeDirProperty( String name , String value ) throws SVNException {
  37     }
  38 
  39     public void addFile( String path , String copyFromPath , long copyFromRevision ) throws SVNException {
  40         File file = new File( myRootDirectory , path );
  41         if ( file.exists( ) ) {
  42             SVNErrorMessage err = SVNErrorMessage.create( SVNErrorCode.IO_ERROR , "error: exported file ''{0}'' already exists!" , file );
  43             throw new SVNException( err );
  44         }
  45 
  46         try {
  47             file.createNewFile( );
  48         } catch ( IOException e ) {
  49             SVNErrorMessage err = SVNErrorMessage.create( SVNErrorCode.IO_ERROR , "error: cannot create new  file ''{0}''" , file );
  50             throw new SVNException( err );
  51         }
  52     }
  53         
  54     public void openFile( String path , long revision ) throws SVNException {
  55     }
  56 
  57     public void changeFileProperty( String path , String name , String value ) throws SVNException {
  58     }        
  59 
  60     public void applyTextDelta( String path , String baseChecksum ) throws SVNException {
  61         myDeltaProcessor.applyTextDelta( null , new File( myRootDirectory , path ) , false );
  62     }
  63 
  64     public OutputStream textDeltaChunk( String path , SVNDiffWindow diffWindow )   throws SVNException {
  65         return myDeltaProcessor.textDeltaChunk( diffWindow );
  66     }
  67         
  68     public void textDeltaEnd(String path) throws SVNException {
  69         myDeltaProcessor.textDeltaEnd( );
  70     }
  71         
  72     public void closeFile( String path , String textChecksum ) throws SVNException {
  73         System.out.println( "file added: " + path );
  74     }
  75 
  76     public void closeDir( ) throws SVNException {
  77     }
  78 
  79     public void deleteEntry( String path , long revision ) throws SVNException {
  80     }
  81         
  82     public void absentDir( String path ) throws SVNException {
  83     }
  84 
  85     public void absentFile( String path ) throws SVNException {
  86     }        
  87         
  88     public SVNCommitInfo closeEdit( ) throws SVNException {
  89         return null;
  90     }
  91         
  92     public void abortEdit( ) throws SVNException {
  93     }
  94 }

   1 public class Export {
   2     
   3     public static void main( String[] args ) { 
   4         DAVRepositoryFactory.setup( );
   5         SVNURL url = SVNURL.parseURIEncoded( "http://svn.svnkit.com/repos/svnkit/trunk/doc" );
   6         String userName = "foo";
   7         String userPassword = "bar";
   8         
   9         //Prepare filesystem directory (export destination).
  10         File exportDir = new File( "export" );
  11         if ( exportDir.exists( ) ) {
  12             SVNErrorMessage err = SVNErrorMessage.create( SVNErrorCode.IO_ERROR , "Path ''{0}'' already exists" , exportDir );
  13             throw new SVNException( err );
  14         }
  15         exportDir.mkdirs( );
  16 
  17         SVNRepository repository = SVNRepositoryFactory.create( url );
  18 
  19         ISVNAuthenticationManager authManager = SVNWCUtil.createDefaultAuthenticationManager( userName, userPassword );
  20         repository.setAuthenticationManager( authManager );
  21 
  22         SVNNodeKind nodeKind = repository.checkPath( "" , -1 );
  23         if ( nodeKind == SVNNodeKind.NONE ) {
  24             SVNErrorMessage err = SVNErrorMessage.create( SVNErrorCode.UNKNOWN , "No entry at URL ''{0}''" , url );
  25             throw new SVNException( err );
  26         } else if ( nodeKind == SVNNodeKind.FILE ) {
  27             SVNErrorMessage err = SVNErrorMessage.create( SVNErrorCode.UNKNOWN , "Entry at URL ''{0}'' is a file while directory was expected" , url );
  28             throw new SVNException( err );
  29         }
  30 
  31         //Get latest repository revision. We will export repository contents at this very revision.
  32         long latestRevision = repository.getLatestRevision( );
  33         
  34         ISVNReporterBaton reporterBaton = new ExportReporterBaton( latestRevision );
  35         
  36         ISVNEditor exportEditor = new ExportEditor( exportDir );
  37         
  38         /*
  39          * Now ask SVNKit to perform generic 'update' operation using our reporter and editor.
  40          * 
  41          * We are passing:
  42          * 
  43          * - revision from which we would like to export
  44          * - null as "target" name, to perform export from the URL SVNRepository was created for, 
  45          *   not from some child directory.
  46          * - reporterBaton
  47          * - exportEditor.  
  48          */
  49         repository.update( latestRevision , null , true , reporterBaton , exportEditor );
  50         
  51         System.out.println( "Exported revision: " + latestRevision );
  52     
  53     }
  54 }