This text is a work in progress—highly subject to
change—and may not accurately describe any released
version of the Apache™ Subversion® software.
Bookmarking or otherwise referring others to this page is
probably not such a smart idea. Please visit
http://www.svnbook.com/
for stable versions of this book.

Strategies for Repository Deployment

Due largely to the simplicity of the overall design of the
Subversion repository and the technologies on which it relies,
creating and configuring a repository are fairly straightforward
tasks. There are a few preliminary decisions you'll want to
make, but the actual work involved in any given setup of a
Subversion repository is pretty basic, tending toward
mindless repetition if you find yourself setting up multiples of
these things.

Some things you'll want to consider beforehand, though, are:

What data do you expect to live in your repository (or
repositories), and how will that data be organized?

Where will your repository live, and how will it be
accessed?

What types of access control do you need?

In this section, we'll try to help you answer those
questions.

Planning Your Repository Organization

While Subversion allows you to move around versioned files
and directories without any loss of information, and even
provides ways of moving whole sets of versioned history from
one repository to another, doing so can greatly disrupt the
workflow of those who access the repository often and come to
expect things to be at certain locations. So before creating
a new repository, try to peer into the future a bit; plan
ahead before placing your data under version control. By
conscientiously “laying out” your repository or
repositories and their versioned contents ahead of time, you
can prevent many future headaches.

Let's assume that as repository administrator, you will be
responsible for supporting the version control system for
several projects. Your first decision is whether to use a
single repository for multiple projects, or to give each
project its own repository, or some compromise of these
two.

There are benefits to using a single repository for
multiple projects, most obviously the lack of duplicated
maintenance. A single repository means that there is one set
of hook programs, one thing to routinely back up, one thing to
dump and load if Subversion releases an incompatible new
version, and so on. Also, you can move data between projects
easily, without losing any historical versioning
information.

The downside of using a single repository is that
different projects may have different requirements in terms of
the repository event triggers, such as needing to send commit
notification emails to different mailing lists, or having
different definitions about what does and does not constitute
a legitimate commit. These aren't insurmountable problems, of
course—it just means that all of your hook scripts have
to be sensitive to the layout of your repository rather than
assuming that the whole repository is associated with a single
group of people. Also, remember that Subversion uses
repository-global revision numbers. While those numbers don't
have any particular magical powers, some folks still don't
like the fact that even though no changes have been made to
their project lately, the youngest revision number for the
repository keeps climbing because other projects are actively
adding new revisions.[51]

A middle-ground approach can be taken, too. For example,
projects can be grouped by how well they relate to each other.
You might have a few repositories with a handful of projects
in each repository. That way, projects that are likely to
want to share data can do so easily, and as new revisions are
added to the repository, at least the developers know that
those new revisions are at least remotely related to everyone
who uses that repository.

After deciding how to organize your projects with respect
to repositories, you'll probably want to think about directory
hierarchies within the repositories themselves. Because
Subversion uses regular directory copies for branching and
tagging (see Chapter 4, Branching and Merging), the
Subversion community recommends that you choose a repository
location for each project
root—the “topmost” directory
that contains data related to that project—and then
create three subdirectories beneath that root:
trunk, meaning the directory under which
the main project development occurs;
branches, which is a directory in which
to create various named branches of the main development line;
and tags, which is a collection of tree
snapshots that are created, and perhaps destroyed, but never
changed.[52]

Note that it doesn't matter where in your repository each
project root is. If you have only one project per repository,
the logical place to put each project root is at the root of
that project's respective repository. If you have multiple
projects, you might want to arrange them in groups inside the
repository, perhaps putting projects with similar goals or
shared code in the same subdirectory, or maybe just grouping
them alphabetically. Such an arrangement might look
like this:

Lay out your repository in whatever way you see fit.
Subversion does not expect or enforce a particular layout—in
its eyes, a directory is a directory is a directory.
Ultimately, you should choose the repository arrangement that
meets the needs of the people who work on the projects that
live there.

In the name of full disclosure, though, we'll mention
another very common layout. In this layout, the
trunk, tags, and
branches directories live in the root
directory of your repository, and your projects are in
subdirectories beneath those, like so:

There's nothing particularly incorrect about such a
layout, but it may or may not seem as intuitive for your
users. Especially in large, multiproject situations with
many users, those users may tend to be familiar with only one
or two of the projects in the repository. But the
projects-as-branch-siblings approach tends to deemphasize project
individuality and focus on the entire set of projects as a
single entity. That's a social issue, though. We like our
originally suggested arrangement for purely practical
reasons—it's easier to ask about (or modify, or migrate
elsewhere) the entire history of a single project when there's
a single repository path that holds the entire
history—past, present, tagged, and branched—for
that project and that project alone.

Deciding Where and How to Host Your Repository

Before creating your Subversion repository, an obvious
question you'll need to answer is where the thing is going to
live. This is strongly connected to myriad other
questions involving how the repository will be accessed (via a
Subversion server or directly), by whom (users behind your
corporate firewall or the whole world out on the open
Internet), what other services you'll be providing around
Subversion (repository browsing interfaces, email-based
commit notification, etc.), your data backup strategy, and so
on.

We cover server choice and configuration in
Chapter 6, Server Configuration, but the point we'd like
to briefly make here is simply that the answers to some of
these other questions might have implications that force your
hand when deciding where your repository will live. For
example, certain deployment scenarios might require accessing
the repository via a remote filesystem from multiple
computers, or using multiple repositories with syncronized
contents distributed geographically to permit more performant
access to that data by users around the globe. Addressing
each possible way to deploy Subversion is both impossible and
outside the scope of this book. We simply encourage you to
evaluate your options using these pages and other sources as
your reference material and to plan ahead.

Controlling Access to Your Repository

Access control in Subversion is almost entirely managed by
the Subversion server processes. We discuss the available
Subversion servers in Chapter 6, Server Configuration, and
explain path-based access control specifically in
the section called “Path-Based Authorization”. In
addition to those user-level access control questions, you'll also
want to ensure that your repository is accessible by the
programs on your hosting machine which need to access it.
Consider the OS-level user and group ownership that makes
sense for your repository. Once again, the information found
in Chapter 6, Server Configuration should be able to help
you make these decisions.

[51] Whether founded in
ignorance or in poorly considered concepts about how to derive
legitimate software development metrics, global revision
numbers are a silly thing to fear,
and not the kind of thing you should
weigh when deciding how to arrange your projects and
repositories.

[52] The trunk,
tags, and branches
trio is sometimes referred to as “the TTB
directories.”