Subversion repository types

Up to now a Subversion repository storage can be represented by either a Berkley DB database (mostly reffered as Berkley DB type) or by an ordinary filesystem (mostly reffered as FSFS type).

Creating a Subversion repository manually

A Subversion distribution package (it can be downloaded from the Subversion home site) includes a tool called svnadmin which is responsible for creating repositories. When you install Subversion you can create a repository performing a command in the command prompt:

...>svnadmin create C:\path

This will create an FSFS repository at the path you specify. You may also explicitly provide the type of a repository back-end:

...>svnadmin create --fs-type bdb C:\path

The layout of a repository root directory looks like this:

 /
 |_conf/
 |_dav/
 |_db/
 |_hooks/
 |_locks/
 |_format
 |_readme.txt

Read official instructions how to create and set up a repository on your computer using official Subversion tools.

Creating a Subversion repository with SVNKit

SVNKit provides an ability to create only FSFS-type repositories. The following is a code snippet which demonstrates how you can create a blank repository using SVNKit:

   1 import org.tmatesoft.svn.core.io.SVNRepositoryFactory;
   2 import org.tmatesoft.svn.core.SVNURL;
   3 import org.tmatesoft.svn.core.SVNException;
   4 ...
   5 
   6     try {
   7         String tgtPath = "C:/repos/root/path";
   8         SVNURL tgtURL = SVNRepositoryFactory.createLocalRepository( new File( tgtPath ), true , false );
   9     } catch ( SVNException e ) {
  10         //handle exception
  11     }
  12 
  13 ...

This will create an FSFS-type repository at path C:/repos/root/path. The second parameter of the createLocalRepository(...) method set to true enables modifications to revision properties of the created repository. As revision properties are unversioned, there's a risk to lose their values forever if changes to them are allowed. To allow revision properties changing you have to place an executable pre-revprop-change hook script file into the hooks directory (see the repository root directory layout above).

When someone is trying to change a revision property, a server (say, svnserve) first invokes a pre-revprop-change hook. If this hook script is not found in the hooks directory, or the script returns a non-zero value, modifications to revision properties are rejected by the server.

When you create a new repository with the Subversion's svnadmin tool a new repository's hook directory contains no real hook files, but only hook templates. This means that you won't be able to change revision properties until you place a pre-revprop-change hook manually into the target hooks directory.

With SVNKit enabling changes to revision properties is quite straightforward. When the second parameter of the createLocalRepository(...) method is true SVNKit places an empty executable pre-revprop-change hook script into the hooks directory of a new repository. Such a hook does nothing, simply returns 0 letting the requested change operation perform. However when this parameter is false no hook script is added (but only templates), and revision properties changing is disabled.

The third parameter of the createLocalRepository(...) method controls whether a repository creation must be forced or not. That is, if this parameter is true and the specified path already exists SVNKit replaces it with a new repository. However if it's false, an existing path (whatever it is) is not removed and a new repository creation fails with an SVNException.

If a repository is successfully created the createLocalRepository(...) method returns a file:/// url of the repository root location. Also you may create an FSFS-type repository with SVNAdminClient - the class belonging to the high-level API. Actually this admin client class uses SVNRepositoryFactory to do the same job.

   1 import org.tmatesoft.svn.core.wc.admin.SVNAdminClient;
   2 import org.tmatesoft.svn.core.SVNURL;
   3 import org.tmatesoft.svn.core.SVNException;
   4 ...
   5     SVNAdminClient adminClient;
   6     ...
   7     try {
   8         String tgtPath = "C:/repos/root/path";
   9         SVNURL tgtURL = adminClient.doCreateRepository( new File( tgtPath ), null , true , false );
  10     } catch ( SVNException e ) {
  11         //handle exception
  12     }
  13 ...

Accessing a repository

There are two ways of accessing a Subversion repository:

over a network
on a local machine

Up to now Subversion supports the following repository access schemes:

Schema	Access Method
`file:///`	direct repository access (on a local disk)
`http://`	access via WebDAV protocol to Subversion-aware Apache server
`https://`	same as `http://`, but with SSL encryption
`svn://`	access via custom protocol to an svnserve server
`svn+ssh://`	same as `svn://`, but through an SSH tunnel

file:/// access

This protocol does not require you to set up a user account for the repository to work with since the repository is located on the same computer. Subversion will use only a user name in commit operations: if no user name is provided explicitly, a session user name is used.

svn://, svn+ssh:// access

To use the svn:// protocol an administrator configures access rules and accounts that will be used by an svnserve program to authenticate users. svn+ssh:// protocol: first a client authenticates himself to a host server over an ssh, a tunneled connection is established and further he works with a repository just like on a local machine. You may try either technique, details are described in this chapter of the Subversion book.

http://, https:// access

To use the http:// protocol an dministrator configures an Apache server with a WebDAV protocol extension module. How to share your repository access over http:// (including account configuration tips), please, be sure to read the Apache dedicated chapter of the Subversion book.