Subversion FAQ
Table of Contents
General questions:
How-to:
- How do I check out the Subversion code?
- How do I create a repository? How do I
import data into it?
- How do I convert an existing CVS repository
into a Subversion repository?
- What if I'm behind a proxy?
- My admins don't want me to have a HTTP server for
Subversion. What can I do if I still want remote usage?
- How do I manage several different projects
under Subversion?
- How do I merge two completely separate repositories?
- Should I store my repository / working copy on a
NFS server?
- Why is my repository taking up so much disk space?
- How do I set repository permissions correctly?
- Why do read-only operations still need repository write access?
- How do I completely remove a file from the repository's history?
- How do I change the log message for a revision
after it's been committed?
- How do I submit a patch for Subversion?
- How can I do an in-place 'import'
(i.e. add a tree to subversion without moving or deleting the
original working copy)?
- What is this "dump/load cycle" people
sometimes talk about when upgrading a Subversion server?
- How do I allow clients to authenticate against a
Windows domain controller using SSPI Authentication?
- I don't like the ".svn" directory name, and
prefer "SVN" or something else. How do I change it?
- How do I change the case of a filename?
- I can't use tags to merge changes from a
branch into the trunk like I used to with CVS, can I?
- Why doesn't the $Revision$
keyword do what I want? It expands to the file's last-changed
revision, but I want something that will expand to the file's
current revision.
- Does Subversion have a keyword which behaves
like $Log$ in CVS?
- I have a file in my project that every
developer must change, but I don't want those local mods to ever be
committed. How can I make 'svn commit' ignore the file?
- When I access a repository using
svn+ssh, my password is not cached in ~/.subversion/auth/. How do
I avoid having to type it so often?
- My
svnserve binary is in a directory that isn't on my
users' default PATHs, they use svn+ssh, and I can't figure
out how to modify their PATH so that they can run svnserve.
- How can I set certain properties on
everything in the repository? Also, how can I make sure that every
new file coming into the repository has these properties?
- How do I determine which version of
Berkeley DB a repository is using?
- I'm managing a website in my
repository. How can I make the live site automatically update after
every commit?
- How do I check out a single
file?
- How do I detect adds, deletes,
copies and renames in a working copy after they've already
happened?
- How do I run svnserve as a service
on Windows?
Troubleshooting:
- My repository seems to get stuck all the
time, giving me errors about needing recovery (DB_RUNRECOVERY).
What could be the cause?
- Every time I try to access
my repository, the process just hangs. Is my repository
corrupt?
- My repository keeps giving
errors saying "Cannot allocate memory". What should I do?
- Every time I try to run a svn
command, it says my working copy is locked. Is my working copy
corrupt?
- I'm trying to commit, but Subversion says my
working copy is out of date?
- I just built the distribution
binary, and when I try to check out Subversion, I get an error
about an "Unrecognized URL scheme." What's up with that?
- I'm getting errors finding or opening a repository,
but I know my repository URL is correct. What's wrong?
- When I run `configure', I
get errors subs-1.sed line 38: Unterminated `s' command. What's wrong?
- I'm having trouble building
Subversion under *NIX with BerkeleyDB 4.2 What should I do?
- I'm getting errors trying to build
Subversion 1.2 on Windows — mod_dav_svn won't build.
- I'm having trouble building
Subversion under Windows with MSVC++ 6.0. What should I do?
- How can I specify a Windows drive letter in
a file: URL?
- I'm having trouble doing write
operations to a Subversion repository over a network.
- VS.NET/ASP.NET seems to have a problem with
the ".svn" directory name. What should I do?
- Under Windows XP, the Subversion
server sometimes seems to send out corrupted data. Can this really be
happening?
- What is the best method of doing a network
trace of the conversation between a Subversion client and server?
- Why does the svn revert require an
explicit target? Why is it not recursive by default? These
behaviors differ from almost all the other subcommands.
- When I start Apache, mod_dav_svn complains about
a "bad database version", that it found db-3.X, rather than
db-4.X.
- I'm getting "Function not implemented" errors on
RedHat 9, and nothing works. How do I fix this?
- Why does SVN log say "(no author)" for files
committed or imported via Apache (ra_dav)?
- I'm getting occasional "Access Denied"
errors on Windows. They seem to happen at random. Why?
- On FreeBSD, certain operations (especially
svnadmin create) sometimes hang. Why?
- I can see my repository in a web browser, but
'svn checkout' gives me an error about "301 Moved Permanently".
What's wrong?
- I'm trying to look at an old version of my
file, but svn says something about "path not found". What's going
on?
- Why doesn't HTTP Digest auth work?
- Compiling with xlc on AIX, I get compilation
errors. What's wrong?
- I checked out a directory
non-recursively (with -N), and now I want to make certain
subdirectories "appear". But svn up subdir doesn't
work.
- I am trying to use mod_dav_svn
with Apache on Win32 and I'm getting an error saying that the
module cannot be found, yet the mod_dav_svn.so file is right
there in \Apache\modules.
- Why aren't my repository hooks working?
- Why does my --diff-cmd complain about '-u'?
I tried to override it with --extensions, but it's not working.
- Ahhh! I just discovered that my
Subversion client is caching passwords in plain-text on disk!
AHHH!
- I'm getting the error "svn: bdb: call
implies an access method which is inconsistent with previous
calls". How do I fix this?
- I can't hotbackup my repository, svnadmin
fails on files larger than 2Gb!
- I cannot see the log entry for the file
I just committed. Why?
- After upgrading to Berkeley DB
4.3, I'm seeing repository errors.
Developer questions:
References:
General questions:
To take over the CVS user base. Specifically, we're writing a new
version control system that is very similar to CVS, but fixes many
things that are broken. See our front page.
No, Subversion is open source / free software. CollabNet pays the
salaries of several full-time developers, and holds the copyright on
the code, but that copyright is an
Apache/BSD-style license
which is fully compliant with the Debian Free
Software Guidelines. In other words, you are free to download,
modify, and redistribute Subversion as you please; no permission from
CollabNet or anyone else is required.
Yes, absolutely. It's ready for prime-time production.
Subversion has been in development since 2000, and became
self-hosting after one year. A year later when we declared "alpha",
Subversion was already being used by dozens of private developers and
shops for real work. After that, it was two more years of bugfixing
and stabilization until we reached 1.0. Most other projects probably
would have called the product "1.0" much earlier, but we deliberately
decided to delay that label as long as possible. We were aware that
many people were waiting for a 1.0 before using Subversion, and had
very specific expectations about the meaning of that label. So we
stuck to that same standard.
The client and server are designed to work as long as they aren't
more than one major release version apart. For example, any 1.X
client will work with a 1.Y server. However, if the client and
server versions don't match, certain features may not be available.
See the client/server interoperability policy is documented in the
"Compatibility" section of the HACKING
file.
All modern flavors of Unix, Win32, BeOS, OS/2, MacOS X.
Subversion is written in ANSI C and uses APR, the Apache Portable Runtime library, as a
portability layer. The Subversion client will run anywhere APR runs,
which is most places. The Subversion server (i.e., the repository
side) is the same, except that it will not host a BDB repository
on Win9x platforms (Win95/Win98/WinME), because Berkeley DB has
shared-memory segment problems on Win9x. FSFS repositories
(introduced in version 1.1) do not have this restriction; however, due
to a limitation in Win9x's file-locking support, they also don't work
in Win9x. That limitation will hopefully be worked around in
1.1.2.
To reiterate, the Subversion client can be run on any platform
where APR runs. The Subversion server can also be run on any
platform where APR runs, but cannot host a repository on
Win95/Win98/WinMe.
No. The "Subversion Filesystem" is not a kernel-level filesystem that
one would install in an operating system. Instead, it refers to the
design of Subversion's repository. The repository is built on a
database (currently Berkeley
DB) and exports a C API that simulates a filesystem -- a
versioned filesystem. Thus writing a program to access the repository
is like writing against other filesystem APIs. The main difference is
that this particular filesystem doesn't lose data when written to; old
versions of files and directories are saved.
No. Subversion is a set of libraries. It comes with a
command-line client that uses them. There are two different
Subversion server processes: either svnserve, which is small
standalone program similar to cvs pserver, or Apache httpd-2.0
using a special mod_dav_svn module. svnserve speaks a
custom protocol, while mod_dav_svn uses WebDAV as its network
protocol. See chapter 6
in the Subversion book to learn more.
The short answer: no.
The long answer: if you just want to access a repository, then you
only need to build a Subversion client. If you want to host a
networked repository, then you need to set up either Apache2 or an
"svnserve" server.
For more details about setting up a network accessible Subversion
server, see chapter 6
in the Subversion book.
No, you can run svnserve as a Subversion server. It works
extremely well.
If you want WebDAV and all the other "goodies" that come with the
Apache server, then yes, you'll need Apache 2.0. It's always an
option to run Apache 2.0 on a different port while continuing to run
Apache 1.x on port 80. Different versions of Apache can happily
coexist on the same machine. Just change the Listen
directive in httpd.conf from "Listen 80" to
"Listen 8080" or whatever port number you want, and make
sure to specify that port when you publish your repository URL (e.g.,
http://svn.mydomain.com:8080/repos/blah/trunk/).
We aren't attempting to break new ground in SCM systems, nor are we
attempting to imitate all the best features of every SCM system out
there. We're trying to replace CVS. See the first question.
The global revision number attached to the repository as a whole is
meaningless from a user's perspective. It's an internal mechanism that
accomplishes the goal of the underlying schema design. It just so
happens to be exposed so that the user's interface can sometimes be a
little more convenient than always having to type obnoxiously long
date/time strings.
The revision number is only relevant to the repository, and user
convenience. It has no impact on any other factor of what you
store in the repository. Repository revision number bumps aren't
nearly useful enough to be an accurate indication of the real rate of
change of a given code base. There are other more complicated ways to
get a much better picture of a code-base's rate of change.
The question is a bit loaded, because everyone seems to have a
slightly different definition of "changeset", or a least a slightly
different expectation of what it means for a version control system to
have "changeset features".
For the purposes of this discussion, here's a simple definition of
changeset: it's a collection of changes with a unique name. The
changes might include textual edits to file contents, modifications to
tree structure, or tweaks to metadata. In more common speak, a
changeset is just a patch with a name you can refer to.
Subversion manages versioned trees as first order objects (the
repository is an array of trees), and the changesets are things that
are derived (by comparing adjacent trees.) Systems like Arch or
Bitkeeper are built the other way around: they're designed to manage
changesets as first order objects (the repository is a bag of
patches), and trees are derived by composing sets of patches
together.
Neither philosophy is better in absolute terms: the debate goes
back at least 30 years. The two designs are better or worse for
different types of software development. We're not going to discuss
that here. Instead, here's an explanation of what you can do with
Subversion.
In Subversion, a global revision number 'N' names a tree in the
repository: it's the way the repository looked after the Nth commit.
It's also the name of an implicit changeset: if you compare tree N
with tree N-1, you can derive the exact patch that was committed.
For this reason, it's easy to think of "revision N" as not just a
tree, but a changeset as well. If you use an issue tracker to manage
bugs, you can use the revision numbers to refer to particular patches
that fix bugs -- for example, "this issue was fixed by revision 9238."
Somebody can then run 'svn log -r9238' to read about the exact
changeset which fixed the bug, and run 'svn diff -r9237:9238' to see
the patch itself. And svn's merge command also uses revision numbers.
You can merge specific changesets from one branch to another by naming
them in the merge arguments: 'svn merge -r9237:9238 branchURL' would
merge changeset #9238 into your working copy.
This is nowhere near as complicated as a system built around
changesets as primary objects, but it's still a vast convenience over
CVS.
See our status page,
http://subversion.tigris.org/project_status.html.
Subversion 1.1 (and later) has the ability to put a symlink under
version control, via the usual svn add command.
Details: the Subversion repository has no internal concept of a
symlink. It stores a "versioned symlink" as an ordinary file with an
'svn:special' property attached. The svn client (on unix) sees the
property and translates the file into a symlink in the working copy.
Win32 has no symlinks, so a win32 client won't do any such
translation: the object appears as a normal file.
Vectorized versions of the Subversion logo are available in the logo directory of the www
tree of the Subversion
repository.
Specifically, an EPS
version, as well as an Adobe
Illustrator document are available.
I have other questions. Where can I get more information?
Please send your questions or concerns to the Subversion Users mailing list. Alternatively,
several Subversion users and developers can usually be contacted via IRC on
channel #svn on irc.freenode.net.
How-to:
Use the subversion client:
$ svn co http://svn.collab.net/repos/svn/trunk subversion
That will check out a copy of the Subversion source tree into a
directory named subversion on your local machine.
See
http://svn.collab.net/repos/svn/trunk/README; specifically, look
at section IV, the "Quickstart Guide".
For even more detail, read chapter 5 in The Subversion Book.
Members of the Subversion development community created and
maintain a tool called cvs2svn. You can find it at http://cvs2svn.tigris.org/. Be
sure to read the README.
If cvs2svn.py does not work for you, (e.g. your repository
causes it to crash, or it doesn't deal with branches and tags
quite how you would like), there are at least two other
conversion utilities you can try. These have different features
(and possibly different bugs):
See also the Subversion links
page.
The Subversion client can go through a proxy, if you configure it
to do so. First, edit your "servers" configuration file
to indicate which proxy to use. The files location depends on your
operating system. On Linux or Unix it is located in the directory
"~/.subversion". On Windows it is in "%APPDATA%\Subversion". (Try
"echo %APPDATA%", note this is a hidden directory.)
There are comments in the file explaining what to do. If you don't
have that file, get the latest Subversion client and run any command;
this will cause the configuration directory and template files to be
created.
Older versions of Subversion, including the 0.14.3 bootstrap
tarball, use the file ~/.subversion/proxies to define the proxy
settings. This file is ignored by the current version of
Subversion.
Next, you need to make sure the proxy server itself supports all
the HTTP methods Subversion uses. Some proxy servers do not support
these methods by default: PROPFIND, REPORT, MERGE, MKACTIVITY,
CHECKOUT. In general, solving this depends on the particular proxy
software. For Squid, the config option is
# TAG: extension_methods
# Squid only knows about standardized HTTP request methods.
# You can add up to 20 additional "extension" methods here.
#
#Default:
# none
extension_methods REPORT MERGE MKACTIVITY CHECKOUT
(Squid 2.4 and later already knows about PROPFIND.)
See also "What are all the HTTP methods
Subversion uses?" for advice on additional HTTP methods to allow
through your proxy.
If it's difficult or impossible to get the proxy to allow
Subversion traffic, but you want to check out the Subversion sources,
you may be able to go around the proxy. Some proxies that filter port
80 nevertheless allow anything on port 81. For this reason, the
svn.collab.net repository server listens on port 81 as well
as on port 80. Try:
svn checkout http://svn.collab.net:81/repos/svn/trunk subversion
and maybe the proxy will let you through. Another strategy is to
attempt the checkout over SSL, which many proxies allow:
svn checkout https://svn.collab.net/repos/svn/trunk subversion
Of course, your svn client will have to have been built with ssl
support; just pass --with-ssl to subversion's
./configure script. You can check to see whether the 'https'
scheme is supported by running svn --version.
A simple option is to use the svnserve server instead of
Apache. See chapter 6
in the Subversion book for details.
However, if your admins don't want you to run Apache, it's very
likely they don't want you to run a custom server process on port 3690
either! So the rest of this answer assumes that your admins
are okay with you using an existing SSH infrastructure.
If you previously used CVS, you may have used SSH to login to the
CVS server. The ra_svn Subversion access method is the equivalent way
of doing this with Subversion. Just use the "svn+ssh" prefix to your
Subversion repository URL.
$ svn checkout svn+ssh://your.domain.com/full/path/to/repository
This makes your SSH program launch a private 'svnserve' process on
the remote box, which accesses the repository as your UID and tunnels
the information back over the encrypted link.
However, another solution that can be used instead is to leverage
SSH port forwarding to connect to the protected server via ra_dav.
You would connect via SSH to a machine behind your firewall that can
access your Subversion server. Note that this SSH server does
not have to be the same as where Subversion is installed. It
can be, but it doesn't have to be.
Then, you create a local port forward that connects to the HTTP
server that houses your Subversion repository. You would then
'connect' to the Subversion repository via this local port. Then,
the request will be sent 'tunneled' via SSH server to your Subversion
server.
An example: a Subversion ra_dav setup is behind your company firewall
at 10.1.1.50 (call it svn-server.example.com). Your company allows SSH
access via publicly accessible ssh-server.example.com. Internally, you
can access the Subversion repository via
http://svn-server.example.com/repos/ours.
Example: client connecting to ssh-server with port-forwarding
and checking out via the port forward
% ssh -L 8888:svn-server.example.com:80 me@ssh-server.example.com
% svn checkout http://localhost:8888/repos/ours
Note that your svn-server.example.com could also have its httpd
instance running on an unprivileged port by a non-trusted user. This
will allow your Subversion server not to require root access.
Joe Orton notes
The server is sensitive to the hostname used in the Destination header
in MOVE and COPY requests, so you have to be a little careful here - a
"ServerAlias localhost" may be required to get this working properly.
Some links on SSH port forwarding
It depends upon the projects involved. If the projects are
related, and are likely to share data, then it's best to create one
repository with several subdirectories like this:
$ svnadmin create /repo/svn
$ svn mkdir file:///repo/svn/projA
$ svn mkdir file:///repo/svn/projB
$ svn mkdir file:///repo/svn/projC
If the projects are completely unrelated, and not likely to share data
between them, then it's probably best to create separate and unrelated
repositories.
$ mkdir /repo/svn
$ svnadmin create /repo/svn/projA
$ svnadmin create /repo/svn/projB
$ svnadmin create /repo/svn/projC
The difference between these two approaches is this (as explained by
Ben Collins-Sussman <sussman@collab.net>):
-
In the first case, code can easily be copied or moved around
between projects, and the history is preserved. ('svn cp/mv'
currently only works within a single repository.)
-
Because revision numbers are repository-wide, a commit to any
project in the first case causes a global revision bump. So it
might seem a bit odd if somebody has 'projB' checked out, notices
that 10 revisions have happened, but projB hasn't changed at
all. Not a big deal, really. Just a little weird at first.
This used to happen to svn everytime people committed to
rapidsvn, when rapidsvn was in the same repository. :-)
-
The second case might be easier to secure; it's easier to insulate
projects from each other (in terms of users and permissions)
using Apache's access control. In the 1st case, you'll need a
fancy hook script in the repository that distinguishes projects
("is this user allowed to commit to this particular subdir?") Of
course, we already have such a script, ready for you to use.
If you don't care about retaining all the history of one of the
repositories, you can just create a new directory under one project's
repository, then import the other.
If you care about retaining the history of both, then you can use
'svnadmin dump' to dump one repository, and 'svnadmin load' to load it into
the other repository. The revision numbers will be off, but you'll
still have the history.
Peter Davis <peter@pdavis.cx> also explains a method using svn's
equivalent to CVS modules:
As long as the merging takes place in separate directory
trees, you can use svn's version of CVS modules.
Set the svn:externals property on a directory to checkout
directories from other repositories whenever the original
directory is checked out. The repository remains separate,
but in the working copy it appears that they have been merged.
If you commit to the imported directory, it will affect the
external repository.
The merge isn't completely clean: the import only affects
working copies, so you won't be able to use a URL in the first
repository to access modules imported from the second. They
remain separate URLs.
If you are using a repository with the Berkeley DB back end
(currently the default), do not access the repository via NFS.
BDB does
not support storage of databases on remote file systems. Some NFS
servers claim that they explicitly support use of BDB on NFS-mounted
partitions, but we've only ever seen BDB databases get corrupted when
living on an NFS or SMB network drive.
If you are using the FSFS
repository back end, then storing the repository on a modern NFS
server (i.e., one that supports locking) should be fine.
Working copies can be stored on NFS (one common scenario is when
your home directory is on a NFS server). On Linux NFS servers, due to
the volume of renames used internally in Subversion when checking out
files, some users have reported that 'subtree checking' should be
disabled (it's enabled by default). Please see NFS Howto
Server Guide and exports(5) for more information on how to
disable subtree checking.
We've had at least one report of working copies getting wedged
after being accessed via SMB. The server in question was running a
rather old version of Samba (2.2.7a). The problem didn't recur with a
newer Samba (3.0.6).
The repository stores all your data in a Berkeley DB "environment"
in the repos/db/ subdirectory. The environment contains a collection
of tables and bunch of logfiles (log.*). Berkeley DB journals all
changes made to the tables, so that the tables can be recovered to a
consistent state in case of interruptions (more info).
The logfiles will grow forever, eating up disk space, unless you,
(as the repository administrator) do something about it. At any given
moment, Berkeley DB is only using a few logfiles actively (see this post and its associated thread); the rest can be safely
deleted. If you keep all the logfiles around forever, then in theory
Berkeley DB can replay every change to your repository from the day it
was born. But in practice, if you're making backups, it's probably
not worth the cost in disk space.
Use svnadmin
to see
which log files can be deleted. You may want a cron job to do this.
$ svnadmin list-unused-dblogs /repos
/repos/db/log.000003
/repos/db/log.000004
[...]
$ svnadmin list-unused-dblogs /repos | xargs rm
# disk space reclaimed!
You could instead use Berkeley DB's db_archive
command:
$ db_archive -a -h /repos/db | xargs rm
# disk space reclaimed!
See also svnadmin hotcopy
or hotbackup.py
.
Note: If you use Berkeley DB 4.2, Subversion 0.35
or later will create new repositories with automatic log file removal
enabled. You can change this by passing the --bdb-log-keep
option to svnadmin create
. Refer to the section about the
DB_LOG_AUTOREMOVE
flag in the Berkeley DB manual.
Try to have as few users access the repository as
possible. For example, run apache or 'svnserve -d' as a specific
user, and make the repository wholly owned by that user. Don't allow
any other users to access the repository via file:/// urls,
and be sure to run 'svnlook' and 'svnadmin' only as the user which
owns the repository.
If your clients are accessing via file:/// or
svn+ssh://, then there's no way to avoid access by multiple
users. In that case, read the last
section in chapter 6, and pay particular attention to the
"checklist" sidebar at the bottom. It outlines a number of steps to
make this scenario safer.
Note for SELinux / Fedora Core 3+ / RedHat Enterprise users:
In addition to regular Unix permissions, under SELinux every file,
directory, process, etc. has a 'security context'. When a process
attempts to access a file, besides checking the Unix permissions the
system also checks to see if the security context of the process is
compatible with the security context of the file.
Fedora Core 3, among other systems, comes with SELinux installed by
default, configured so that Apache runs in a fairly restricted
security context. To run Subversion under Apache, you have to set the
security context of the repository to allow Apache access (or turn off
the restrictions on Apache, if you think all this is overkill). The
chcon command is used to set the security context of files
(similarly to how the chmod sets the traditional Unix
permissions). For example, one user had to issue this command
$ chcon -R -h -t httpd_sys_content_t PATH_TO_REPOSITORY
to set the security context to be able to successfully
access the repository.
Certain client operations are "read-only", like checkouts and
updates. From an access-control standpoint, apache treats them as
such. But libsvn_fs (the repository filesystem API) still has to
write temporary data in order to produce tree-deltas. So the process
accessing the repository always requires both read and write
access to the Berkeley DB files in order to function.
In particular, the repository responds to many "read-only"
operations by comparing two trees. One tree is the usually the HEAD
revision, and the other is often a temporary transaction-tree -- thus
the need for write access.
This limitation only applies to the bdb backend; the FSFS
backend does not exhibit this behaviour.
There are special cases where you might want to destroy all
evidence of a file or commit. (Perhaps somebody accidentally committed
a confidential document.) This isn't so easy, because Subversion is
deliberately designed to never lose information. Revisions are
immutable trees which build upon one another. Removing a revision from
history would cause a domino effect, creating chaos in all subsequent
revisions and possibly invalidating all working copies.
The project has plans, however, to someday implement an svnadmin
obliterate command which would accomplish the task of permanently
deleting information. (See issue
516.)
In the meantime, your only recourse is to svnadmin dump your
repository, then pipe the dumpfile through svndumpfilter
(excluding the bad path) into an svnadmin load command. See chapter 5
of the Subversion book for details about this.
Log messages are kept in the repository as properties attached to each
revision. By default, the log message property (svn:log) cannot be
edited once it is committed. That is because changes to revision
properties (of which svn:log is one) cause the property's
previous value to be permanently discarded, and Subversion tries to prevent
you from doing this accidentally. However, there are a couple of ways to get
Subversion to change a revision property.
The first way is for the repository administrator to enable revision
property modifications. This is done by creating a hook called
"pre-revprop-change" (see this
section in the Subversion book for more details about how to do this).
The "pre-revprop-change" hook has access to the old log message before it is
changed, so it can preserve it in some way (for example, by sending an email).
Once revision property modifications are enabled, you can change a revision's
log message by passing the --revprop switch to svn propedit or svn
propset, like either one of these:
$ svn propedit -r N --revprop svn:log URL
$ svn propset -r N --revprop svn:log "new log message" URL
where N is the revision number whose log message you wish to change, and
URL is the location of the repository. If you run this command from within a
working copy, you can leave off the URL.
The second way of changing a log message is to use svnadmin setlog.
This must be done by referring to the repository's location on the filesystem.
You cannot modify a remote repository using this command.
$ svnadmin setlog REPOS_PATH -r N FILE
where REPOS_PATH is the repository location, N is the revision number whose
log message you wish to change, and FILE is a file containing the new log
message. If the "pre-revprop-change" hook is not in place (or you want to
bypass the hook script for some reason), you can also use the --bypass-hooks
option. However, if you decide to use this option, be very careful. You may
be bypassing such things as email notifications of the change, or backup
systems that keep track of revision properties.
FIRST, read the HACKING document.
Once you've digested that, send a mail to the dev list with the
word [PATCH] and a one-line description in the subject, and include
the patch inline in your mail (unless your MUA munges it up
totally). Then a committer will pick it up, apply it (making any
formatting or content changes necessary), and check it in.
The basic process looks like this:
$ svn co http://svn.collab.net/repos/svn/trunk subversion
$ cd subversion/www
[ make changes to faq.html ]
$ svn diff faq.html > /tmp/foo
$ Mail -s "[PATCH] FAQ updates" < /tmp/foo
Of course, the email you send should contain a nice long
explanation about what the patch does, as per the
HACKING
document, but you already know that, since you read and completely
understood it
before actually hacking the code, right? :)
Suppose, for example, that you wanted to put some of /etc under
version control inside your repository:
# svn mkdir file:///root/svn-repository/etc \
-m "Make a directory in the repository to correspond to /etc"
# cd /etc
# svn checkout file:///root/svn-repository/etc .
# svn add apache samba alsa X11
# svn commit -m "Initial version of my config files"
This takes advantage of a not-immediately-obvious feature of
svn checkout: you can check out a directory from the repository
directly into an existing directory. Here, we first make a new empty directory
in the repository, and then check it out into /etc, transforming
/etc into a working copy. Once that is done, you can use normal
svn add commands to select files and subtrees to add to the
repository.
There is an issue filed for enhancing svn import to
be able to convert the imported tree to a working copy automatically;
see issue 1328.
Subversion's repository database schema has changed occasionally
during development. Old repositories, created with a pre-1.0
development version of Subversion, may require the following operation
when upgrading. If a schema change happens between Subversion
releases X and Y, then repository administrators upgrading to Y must
do the following:
- Shut down svnserve, Apache, and anything else that might be
accessing the repository.
-
svnadmin dump /path/to/repository > dumpfile.txt
,
using version X of svnadmin.
-
mv /path/to/repository /path/to/saved-old-repository
- Now upgrade to Subversion Y (i.e., build and install Y, replacing X).
-
svnadmin create /path/to/repository, using version
Y of svnadmin.
-
svnadmin load /path/to/repository < dumpfile.txt
,
again using version Y of svnadmin.
- Copy over hook scripts, etc, from the old repository to the new one.
- Restart svnserve, Apache, etc.
See
http://svnbook.red-bean.com/html-chunk/ch05s03.html#svn-ch-5-sect-3.4
for more details on dumping and loading.
Note: Most upgrades of Subversion do not involve a
dump and load. When one is required, the release announcement and the
CHANGES file for the new version will carry prominent notices about
it. If you don't see such a notice, then there has been no schema
change, and no dump/load is necessary.
TortoiseSVN has an excellent
document that describes setting up a Subversion server on Windows. Go to
http://tortoisesvn.tigris.org/docs/TortoiseSVN_en/ch03.html#tsvn-serversetup-apache-5,
to see the section on SSPI authentication.
An earlier version of this document left out a line:
SSPIOfferBasic On
Without this line, a browser will prompt for the user's credentials,
but Subversion clients will not. (The browser understands SSPI
authentication, but the current release of Neon - Subversion's HTTP
library - handles only basic authentication.) Because the client never
asks for credentials, any action that requires authentication will fail.
Adding this line tells mod_auth_sspi to use basic authentication with
the client, but to use the Windows domain controller to authenticate
the credentials.
We recommend that you live with ".svn" if you possibly can. If you
use some other name, your working copy may not work with Subversion
clients other than the one you regularly use. However, if you
absolutely must, you can simply change this line in
subversion/include/svn_wc.h from
#define SVN_WC_ADM_DIR_NAME ".svn"
to
#define SVN_WC_ADM_DIR_NAME "SVN"
then recompile your client.
This problem comes up in two situations. If you're adding files on
an operating system with a case-insensitive filesystem, such as
Windows, you might find you accidentally add a file with the wrong
case in the filename. Alternatively, you may just decide to change
the case of an existing file in the repository.
If you're working in a case-sensitive file system, this is no
problem at all. Just move the file to the new name, e.g.,
svn mv file.java File.java
But this won't work in a case-insensitive operating system like
Windows. In Windows you can accomplish this by copying the file
somewhere temporary, deleting the file from Subversion, then adding
the copy with the correct case. Or a better way is to perform a move
operation with Subversion URLs. Using URLs is recommended, because it
will preserve history for the file, and will take effect
immediately.
Both ways will leave Windows working copies with problems, however,
because Windows can still get confused when trying to update the
conflicting filenames. (You'll get a message like svn: Failed to
add file 'File.java': object of the same name already
exists). One way of fixing the problem is to delete your working
copy and check out again. If you do not want to do this, you must
perform a two step update.
For each file with the wrong case, the following command will change
the case:
svn mv svn://svnserver/path/to/file.java svn://svnserver/path/to/File.java
To update the working copy, change to the relevant directory and do:
svn update file.java
svn update
The first update will remove file.java from your working
copy, the second update will add File.java, leaving you with
a correct working copy. Or if you had a lot of problematic files, you
can update the working copy this way:
svn update *
svn update
As you can see, adding a file with the wrong case is tricky to fix on
an operating system that has a case insensitive filesystem. Do try to
get it right when you add the file the first time!
As shown below it is possible to merge from a branch to the trunk
without remembering one revision number. Or vice versa (not shown in the
example).
The example below presumes an existing repository in /home/repos
in which you want to start a branch named bar containing a file
named foo you are going to edit.
For the purpose of tracing branch merges, this repository has set up
tags/branch_traces/ to keep tags.
# setup branch and tags
$ svn copy file:///home/repos/trunk \
file:///home/repos/branches/bar_branch \
-m "start of bar branch"
$ svn copy file:///home/repos/branches/bar_branch \
file:///home/repos/tags/branch_traces/bar_last_merge \
-m "start"
# checkout branch working copy
$ svn checkout file:///home/repos/branches/bar_branch wc
$ cd wc
# edit foo.txt file and commit
$ echo "some text" >>foo.txt
$ svn commit -m "edited foo"
# switch to trunk and merge changes from branch
$ svn switch file:///home/repos/trunk
$ svn merge file:///home/repos/tags/branch_traces/bar_last_merge \
file:///home/repos/branches/bar_branch
# Now check the file content of 'foo.txt', it should contain the changes.
# commit the merge
$ svn commit -m "Merge change X from bar_branch."
# finally, update the trace branch to reflect the new state of things
$ svn delete -m "Remove old trace branch in preparation for refresh." \
file:///home/repos/tags/branch_traces/bar_last_merge
$ svn copy file:///home/repos/branches/bar_branch \
file:///home/repos/tags/branch_traces/bar_last_merge \
-m "Reflect merge of change X."
Subversion increments the revision number of the repository as a
whole, so it can't expand any keyword to be that number - it would
have to search and possibly modify every file in your working copy on
every update and commit.
The information you want (the revision of your working copy) is
available from the command svnversion; it gives you
information on the revision level of a working copy given a path (see
svnversion --help for details).
You can incorporate it into your build or release process to get the
information you need into the source itself. For example, in a build
environment based on make, add something like this to your
Makefile:
##
## on every build, record the working copy revision string
##
svn_version.c: FORCE
echo -n 'const char* svn_version(void) { const char* SVN_Version = "' \
> svn_version.c
svnversion -n . >> svn_version.c
echo '"; return SVN_Version; }' >> svn_version.c
any executable that links in svn_version.o will be able to
call the function svn_version() to get a string that
describes exactly what revision was built.
Windows users may want to use SubWCRev.exe, available from
the TortoiseSVN
download page; it replaces all $WCREV$ tags in a given
file with the current working copy revision.
No. There is no equivalent for the $Log$ keyword in CVS. If you
want to retrieve a log for a specific file, you can run
'svn log your-file-name' or 'svn log url-to-your-file'.
From the mailing list some explanations why $Log$ is bad:
"$Log$ is a total horror the moment you start merging changes
between branches. You're practically guaranteed to get conflicts there,
which -- because of the nature of this keyword -- simply cannot be
resolved automatically."
And:
Subversion log messages are mutable, they can be changed by setting
the svn:log revision property. So the expansion of $Log:$ in any
given file could be out of date. Update may well need to retrieve the
appropriate log message for each occurrence of the $Log:$ keyword,
even if the file that contained it was not otherwise updated.
I don't care about that. I want to use it anyway.
Will you implement it?
No. There are no plans to implement it ourselves or accept patches
which implement this feature. If you want to distribute your files
with some kind of changelog included, you might be able to work
around this limitation in your build system.
The answer is: don't put that file under version control. Instead,
put a template of the file under version control, something
like "file.tmpl".
Then, after the initial 'svn checkout', have your users (or your
build system) do a normal OS copy of the template to the proper
filename, and have users customize the copy. The file is unversioned,
so it will never be committed. And if you wish, you can add the file
to its parent directory's svn:ignore property, so it doesn't show up
as '?' in the 'svn status' command.
ssh has its own passphrases and its own authentication-caching
scheme. Its auth caching is external to Subversion, and must be set
up independently of Subversion.
OpenSSH includes ssh-keygen to create the keys,
ssh-agent to cache passphrases, and
ssh-add to add passphrases to the agent's cache. A
popular script to simplify usage of ssh-agent is
keychain. On Windows, PuTTY is a
popular alternative ssh client; see PuTTYgen to import
OpenSSH keys and pageant to cache passphrases.
Setting up ssh-agent is outside the scope of this
document, but a Google search for "ssh-agent" will quickly get you answers. Or
if you're really impatient, try one of these:
http://www.csua.berkeley.edu/ssh-howto.html
http://mah.everybody.org/docs/ssh
http://kimmo.suominen.com/docs/ssh/
Note: this all assumes you're using OpenSSH. There are other
ssh implementations out there, and presumably they will allow
you to do something similar, but we don't yet know the details.
You've tried fiddling with their various login files, like
.bash_profile, and nothing works! That's because ssh
ignores those files when the subversion client invokes it.
But there's no need to modify PATH; instead, you can
directly give ssh the full name of the svnserve command.
Here's how to do it:
For each user who needs svn+ssh access, generate a new ssh
public-key pair which they will use only for
subversion—not for logging in normally. Have them give
the keypair a distinctive name, like
~/.ssh/id_dsa.subversion. Add the public part of the
key to their ~/.ssh/authorized_keys file on the
server machine, after first inserting a bit of magic at the
beginning of the line before the word ssh-rsa or
ssh-dss, like this:
before |
ssh-dss AAAAB3Nblahblahblahblah |
after |
command="/opt/subversion/bin/svnserve -t" ssh-dss AAAAB3Nblahblahblahblah
|
Obviously, replace /opt/subversion/bin/svnserve with
whatever is appropriate for your system. You also might want to
specify the full path to the subversion repository in the
command (by using the -r option), to save your users
some typing.
The command= magic causes sshd on the remote machine
to invoke svnserve, even if your user tries to run
some other command. See the sshd(8) man page (section
AUTHORIZED_KEYS FILE FORMAT) for details.
Now when your users run the subversion client, make sure they
have an SVN_SSH environment variable that "points to"
the private half of their keypair, by doing something like this
(for the Bourne Again shell):
SVN_SSH="ssh -i $HOME/.ssh/id_dsa.subversion"
export SVN_SSH
Subversion will not change a file's contents by default; you have
to deliberately set the svn:eol-style or
svn:keywords property on a file for that to happen. That
makes Subversion a lot safer than CVS's default behavior, but with
that safety comes some inconvenience.
Answering the first question: to set properties on all files
already in the repository, you'll need to do it the hard way. All you
can do is run svn propset on every file (in a working copy),
and then svn commit. Scripting can probably help you with
this.
But what about future files? Unfortunately, there's no server
mechanism to automatically set properties on files being committed.
This means that all of your users need to remember to set certain
properties whenever they svn add a file. Fortunately,
there's a client-side tool to help with this. Read about the
auto-props feature in the book. You need to make sure all your
users configure their clients' auto-props settings appropriately.
You could write a pre-commit hook script to reject any commit which
forgets to add properties to new files (see http://svn.collab.net/repos/svn/trunk/contrib/hook-scripts/check-mime-type.pl
for example). However, this approach may be overkill. If somebody
forgets to set svn:eol-style, for example, it will be noticed
the minute somebody else opens the file on a different OS. Once
noticed, it's easy to fix: just set the property and commit.
Note: many users have asked for a feature whereby the server
automatically "broadcasts" run-time settings to clients, such as
auto-props settings. There's already a feature request filed for this
(issue
1974), though this feature is still being debated by developers,
and isn't being worked on yet.
If it's a live repository, then the easy answer is "Whatever version
of BDB you have installed". If, however, it is a repository from a
backup, or some unknown source, and you have no idea which version of
BDB it was made with, here's how you find out:
Run some command to view the two 4-byte integers at offsets 12 and 16
(decimal) in the highest-numbered db/log.* file in the repository. Here
is an example using GNU od: "od -j12 -N8 -tx4
log.<number>". Here is an example using Mac OS X
hexdump: "hexdump -s12 -n8 -x log.<number>". The
first integer should be the magic number 0x00040988, which identifies
the file as a BDB logfile. The second number is the log format version
- match it to a BDB program version
using the table below:
Log format version | BDB program version |
5 (0x00000005) | 4.0 |
7 (0x00000007) | 4.1 |
8 (0x00000008) | 4.2 |
10 (0x0000000a) | 4.3 |
This is done all the time, and is easily accomplished by adding a
post-commit hook script to your repository. Read about hook scripts
in Chapter
5 of the book. The basic idea is to make the "live site" just an
ordinary working copy, and then have your post-commit hook script run
'svn update' on it.
In practice, there are a couple of things to watch out for. The
server program performing the commit (svnserve or apache) is the same
program that will be running the post-commit hook script. That means
that this program must have proper permissions to update the working
copy. In other words, the working copy must be owned by the same user
that svnserve or apache runs as -- or at least the working copy must
have appropriate permissions set.
If the server needs to update a working copy that it doesn't own
(for example, user joe's ~/public_html/ area), one technique is create
a +s binary program to run the update, since Unix won't allow scripts
to run +s. Compile a tiny C program:
#include <stdlib.h>
int main(int argc, const char *argv[])
{
system("/usr/local/bin/svn update /home/joe/public_html/");
}
... and then chmod +s the binary, and make sure it's owned
by user 'joe'. Then in the post-commit hook, add a line to run the
binary.
Also, you'll probably want to prevent apache from exporting the
.svn/ directories in the live working copy. Add this to your
httpd.conf:
# Disallow browsing of Subversion working copy administrative dirs.
<DirectoryMatch "^/.*/\.svn/">
Order deny,allow
Deny from all
</DirectoryMatch>
Subversion does not support checkout of a single file, it only
supports checkout of directory structures.
However, you can use 'svn cat' to export a single file. This will
retrieve the file's contents, it just won't create a versioned working
copy.
You don't. It's a bad idea to try.
The basic design of the working copy has two rules: (1) edit files
as you please, and (2) use a Subversion cilent to make any
tree-changes (add, delete, move, copy). If these rules are followed,
the client can sucessfully manage the working copy. If renames or
other rearrangements happen outside of Subversion, then the UI has
been violated and the working copy might be broken. The client cannot
guess what happened.
People sometimes run into this problem because they want to make
version control "transparent". They trick users into using a working
copy, then have a script run later that tries to guess what happened
and run appropriate client commands. Unfortunately, this technique
only goes a short distance. 'svn status' will show missing items and
unversioned items, which the script can then automatically 'svn rm' or
'svn add'. But if a move or copy has happened, you're out of luck.
Even if the script has a foolproof way of detecting these things, 'svn
mv' and 'svn cp' can't operate after the action has already
occurred.
In summary: a working copy is wholly under Subversion's control,
and Subversion wasn't designed to be transparent. If you're looking
for transparency, try setting up an apache server and using the
"SVNAutoversioning" feature described in appendix C of the book. This
will allow users to mount the repository as a network disk, and any
changes made to the volume cause automatic commits on the server.
The svnserve binary itself cannot be installed as a
Windows service, but there are a number of “service
wrappers” that can do the job; for example:
- SVNService
is a free tool written by Magnus Norddahl
- SrvAny
is avaliable free of charge from Microsoft
Troubleshooting:
The BerkeleyDB database in your repository is sensitive to
interruptions. If a process accessing the database exits without
"cleanly" closing the environment, then the database is left in an
inconsistent state. Common causes of this include:
- the process exiting when it hits a permission problem
- the process crashing/segfaulting
- the process being forcibly killed
- running out of disk space
For most of these cases, you should run "svnadmin recover", which
rewinds the repository back to a consistent state; see this question for details. Note that running
out of disk space, combined with frequent checkouts or updates, can
cause the repository to crash in a way where recovery is not possible
(so keep backups).
Segfaults, forced killings, and running out of disk space are
pretty rare. Permission problems are far more common: one process
accesses the repository and accidentally changes ownership or
permissions, then another process tries to access and chokes on the
permissions.
The best way to prevent this is to get your repository permissions
and ownership set up correctly. See here
for our recommendations.
Your repository is not corrupt, nor is your data lost. If your process
accesses the repository directly (mod_dav_svn, svnlook, svnadmin, or
if you access a `file://' URL), then it's using Berkeley DB to access
your data. Berkeley DB is journaling system, meaning that it logs
everything it is about to do before it does so. If your process is
interrupted (Control-C, or segfault), then a lockfile is left behind,
along with a logfile describing unfinished business. Any other
process that attempts to access the database will just hang, waiting
for the lockfile to disappear. To awaken your repository, you need to
ask Berkeley DB to either finish the work, or rewind the database to a
previous state that is known to be consistent.
WARNING: you can seriously corrupt
your repository if you run recover and another process accesses the
repository.
Make absolutely sure you disable all access to the repository before
doing this (by shutting down Apache, removing executable permissions from
'svn'). Make sure you run this command as the user that owns and manages
the database, and not as root, else it will leave root-owned files in the
db directory which cannot be opened by the non-root user that manages the
database, which is typically either you or your Apache process. Also be
sure to have the correct umask set when you run recover, since failing to
do so will lock out users that are in the group allowed to access the
repository.
Simply run:
svnadmin recover /path/to/repos
Once the command has completed, check the permissions in the
db
directory of the repository.
If you're using http:// access, "Cannot allocate memory"
errors show up in the httpd error log and look something like
this:
[Wed Apr 07 04:26:10 2004] [error] [client 212.151.130.227] (20014)
Error string not specified yet: Berkeley DB error while opening
'strings' table for filesystem /usr/local/svn/repositories/svn/db:
Cannot allocate memory
[Wed Apr 07 04:26:10 2004] [error] [client 212.151.130.227]
Could not fetch resource information. [500, #0]
[Wed Apr 07 04:26:10 2004] [error] [client 212.151.130.227]
Could not open the requested SVN filesystem [500, #160029]
[Wed Apr 07 04:26:10 2004] [error] [client 212.151.130.227] (17)
File exists: Could not open the requested SVN filesystem [500, #160029]
It usually means that a Berkeley DB repository has run out of
database locks (this does not happen with FSFS repositories). It
shouldn't happen in the course of normal operations, but if it does,
the solution is to run database recovery as described here. If it happens often, you probably need
to raise the default lock parameters (set_lk_max_locks,
set_lk_max_lockers, and set_lk_max_objects) in the
db/DB_CONFIG file. When changing DB_CONFIG in an existing repository,
remember to run recovery afterwards.
Your working copy is not corrupt, nor is your data lost. Subversion's
working copy is journaling system, meaning that it logs everything it
is about to do before it does so. If the svn client program is
interrupted violently (segfault or killed, not with Control-C), then
one or more lockfiles are left behind, along with logfiles describing
unfinished business. (The`svn status' command will show an 'L' next
to locked directories.) Any other process that attempts to access the
working copy will fail when it sees the locks. To awaken your working
copy, you need to tell the svn client to finish the work. Simply
run:
svn cleanup working-copy
Three kinds of situation that can cause this:
Debris from a failed commit is littering your working copy.
You may have had a commit that went sour between the time the
new revision was added in the server and the time your client
performed its post-commit admin tasks (including refreshing your
local text-base copy). This might happen for various reasons
including (rarely) problems in the database back end or (more
commonly) network dropouts at exactly the wrong time.
If this happens, it's possible that you have already committed
the very changes you are trying now to commit. You can use 'svn
log -rHEAD' to see if your supposed-failed commit actually
succeeded. If it did, run 'svn revert' to revert your local
changes, then run 'svn update' to your own changes back from the
server. (Note that only 'svn update' brings your local copies
up-to-date; revert doesn't do that.)
Mixed revisions.
When Subversion commits, the client only bumps the revision
numbers of the nodes the commit touches, not all nodes in the
working copy. This means that in a single working copy, the
files and subdirectories might be at different revisions,
depending on when you last committed them. In certain operations
(for example, directory property modifications), if the
repository has a more recent version of the node, the commit will
be rejected, to prevent data loss. See
The Limitations of Mixed Revisions in the Version Control with
Subversion for details.
You can fix the problem by running 'svn update' in the working
copy.
You might be genuinely out of date — that is,
you're trying to commit a change to a file that has been changed
by someone else since you last updated your copy of that file.
Again, 'svn update' is the way to fix this.
Subversion uses a plugin system to allow access to repositories.
Currently there are three of these plugins: ra_local allows access to
a local repository, ra_dav which allows access to a repository via
WebDAV, and ra_svn allows local or remote access via the svnserve
server. When you attempt to perform an operation in subversion, the
program tries to dynamically load a plugin based on the URL scheme. A
`file://' URL will try to load ra_local, and an `http://' URL will try
to load ra_dav.
The error you are seeing means that the dynamic linker/loader can't find
the plugins to load. This normally happens when you build subversion with
shared libraries, then attempt to run it without first running 'make
install'. Another possible cause is that you ran make install, but the
libraries were installed in a location that the dynamic linker/loader
doesn't recognize. Under Linux, you can allow the linker/loader to find the
libraries by adding the library directory to /etc/ld.so.conf and running
ldconfig. If you don't wish to do this, or you don't have root access, you
can also specify the library directory in the LD_LIBRARY_PATH environment
variable.
See this faq.
You probably have old copies of
/usr/local/bin/apr-config and
/usr/local/bin/apu-config on your system. Remove them, make
sure the apr/ and apr-util/ that you're
building with are completely up-to-date, and try again.
Subversion compiles against BerkeleyDB by asking apr-util for the
appropriate BDB build options. This means that either the apr-util in
your Subversion tarball or the one in your Apache tree must
successfully detect BDB. Normally one does this by passing
"--with-berkeley-db" to apr-util's ./configure. (When you pass this
argument to either Apache or Subversion's ./configure, it's really
just getting passed down to apr-util's ./configure.)
The problem is that BerkeleyDB 4.2 is newer than the latest
released version of apr-util, so apr-util doesn't know how to detect
it.
The long-term solution is already in place: the latest apr-util in
CVS has code to explicitly detect BDB 4.2. When either apr-util or
Apache httpd does another release, this ability will widely
available.
In the short term, the best thing to do is apply this patch to your apr-util's
./configure script -- either to the apr-util in your apache tree (if
you're building Apache before Subversion), or to the apr-util in your
Subversion tarball (if you're not building Apache at all.) This patch
is the new DB 4.2 detection code already in the latest apr-util
CVS.
If you've building Apache first, apply the patch to httpd-2.0.48's
apr-util's configure script, and then build with these options:
$ configure \
--enable-dav \
--enable-so \
--with-berkeley-db=/usr/local/BerkeleyDB.4.2 \
--with-dbm=db42
You can confirm that Apache is built with the proper BDB libraries with the
following command:
$ ldd /usr/local/apache2/bin/httpd | fgrep libdb
libdb-4.2.so => /usr/local/BerkeleyDB.4.2/lib/libdb-4.2.so
And then you can simply build Subversion with no mention of BDB.
(...although Subversion might need to be told where to find
your Apache installation, if it's in a non-standard place.)
If you're not building Apache, apply the patch to the apr-util
./configure script in your Subversion tree, and use similar build
options:
$ configure \
--with-berkeley-db=/usr/local/BerkeleyDB.4.2 \
--with-dbm=db42
Again, you can confirm that Subversion was built against the proper BDB
library with the following:
$ ldd /usr/local/bin/svn | fgrep libdb
libdb-4.2.so => /usr/local/BerkeleyDB.4.2/lib/libdb-4.2.so
If you install your libraries in locations other than the defaults, you would
need to adjust the paths at each step accordingly.
It turns out that there's a small build-bug Apache httpd: not all
of mod_dav's public APIs were properly declared "exportable"
on Windows. And Subversion 1.2's mod_dav_svn is now using
these APIs. This means that out-of-the-box, Subversion 1.2 will not
compile on Windows against any released httpd sourceball.
This problem is already fixed on httpd's /trunk, and has been
backported to the httpd 2.0.x branch. If you're using a released
httpd source tree, you're out of luck. Until httpd-2.0.54 is
released, you will need to manually apply the same patch to your httpd tree.
(It's r155345 of httpd's trunk, for reference.)
Probably you just need to get the latest platform SDK. The one that
ships with VC++ 6.0 is not recent enough.
Like this:
svn import file:///d:/some/path/to/repos/on/d/drive
See
Repository URLs in the Subversion Book for more details.
VS.Net has a subsystem called ASP.Net, which uses WebDAV to do
remote publishing through IIS. This subsystem rejects any pathname
that starts with ".". This causes a problem when you try to remotely
publish a Subversion working copy, because of the ".svn"
subdirectories. The error message says something like "unable to
read project information".
There are a few solutions:
Recompile your client to use a different working copy name, as
described here. Or,
If you use TortoiseSVN, you can download a client that is
already modified to work around the problem, see
http://tortoisesvn.tigris.org/download.html. Or,
Take Jim Bolla's advice from
http://weblogs.asp.net/fbouma/archive/2004/02/28/81479.aspx:
"If you're working on web projects locally or across a file
share, you can get around this by converting it to a regular class
library project. I have some docementation on how to do this that
i've compiled from various sources on the internet about how to do
this." (We've contacted Jim Bolla about getting that
documentation, and will include it here if we can.). Or,
Steele Price, also on
http://weblogs.asp.net/fbouma/archive/2004/02/28/81479.aspx,
says:
"You can get around the .SVN directory pretty easily by
following instructions here: http://staff.develop.com/onion/Samples/aspdotnet_without_web_projects.htm
further instruction for making new projects is here:
http://blog.steeleprice.net/archive/2003/11/09/134.aspx"
For example, one user reported that imports worked fine over local
access:
$ mkdir test
$ touch test/testfile
$ svn import test file:///var/svn/test -m "Initial import"
Adding test/testfile
Transmitting file data .
Committed revision 1.
But not from a remote host:
$ svn import http://svn.sabi.net/test testfile -m "import"
nicholas's password: xxxxxxx
svn_error: #21110 : <Activity not found>
The specified activity does not exist.
We've seen this when the REPOS/dav/ directory is not writable by
the httpd process. Check the permissions to ensure Apache can write
to the dav/ directory (and to db/, of course).
You need to install Window XP Service Pack 1. You can get all
sorts of information about that Service Pack here:
Use Ethereal to eavesdrop
on the conversation:
- Pull down the Capture menu, and choose Start.
- Type
port 80
for Filter, and turn off
promiscuous mode.
- Run your Subversion client.
- Hit Stop (probably in a little box). Now you have a
capture. It looks like a huge list of lines.
- Click on the Protocol column to sort.
- Then, click on the first relevant TCP line to select it.
- Right click, and choose Follow TCP Stream. You'll be
presented with the request/response pairs of the Subversion
client's HTTP conversion.
The above instructions are specific to the graphical version of
Ethereal, and may not apply to the commandline version (whose binary
is usually named tethereal).
Alternatively, if you have an up-to-date client (more recent than
the 0.16 tarball) you may set the neon-debug-mask parameter in your
servers configuration file to cause neon's debugging output
to appear when you run the svn client. The numeric value of
neon-debug-mask is a combination of the NE_DBG_... values
in the header file ne_utils.h. For neon 0.23.7 setting
neon-debug-mask to 130 (i.e. NE_DBG_HTTP+NE_DBG_HTTPBODY)
will cause the HTTP data to be shown.
You may well want to disable compression when doing a network
trace, see the compression parameter in the config
configuration file.
The short answer: it's for your own good.
Subversion places a very high priority on protecting your data, and
not just your versioned data. Modifications that you make to
already-versioned files, and new files scheduled for addition to the
version control system, must be treated with care.
Making the svn revert command require an explicit
target—even if that target is just '.'—is one way of
accomplishing that. This requirement (as well as requiring you to
supply the --recursive (-R) flag if you want that behavior)
is intended to make you really think about what you're doing, because
once your files are reverted, your local modifications are gone
forever.
Your apr-util linked against DB-3, and svn linked against DB-4.
Unfortunately, the DB symbols aren't different. When mod_dav_svn is
loaded into Apache's process-space, it ends up resolving the
symbol names against apr-util's DB-3 library.
The solution is to make sure apr-util compiles against DB-4. You
can do this by passing specific switches to either apr-util's or
apache's configure: "--with-dbm=db4 --with-berkeley-db=/the/db/prefix".
This is not really a problem with Subversion, but it often affects
Subversion users.
RedHat 9 and Fedora ship with a Berkeley DB library that relies on the kernel
support for NPTL (the Native Posix Threads Library).
The kernels that RedHat provides have this support built in, but if you
compile your own kernel, then you may well not have the NPTL support. If that
is the case, then you will see errors like this:
svn: Berkeley DB error
svn: Berkeley DB error while creating environment for filesystem tester/db:
Function not implemented
This can be fixed in one of several ways:
- Rebuild db4 for the kernel you're using.
- Use a RedHat 9 kernel.
- Apply the NPTL patches to the kernel you're using.
- Use a recent (2.5.x) kernel with the NPTL support included.
- Check if environment variable
LD_ASSUME_KERNEL
is set
to 2.2.5
, and if so, unset it before starting
Subversion (Apache). (You usually would set this variable to run
Wine or Winex on RedHat 9)
To use the NPTL version of Berkeley DB you also need to use a glibc
library with NPTL support, which probably means the i686 version. See
http://svn.haxx.se/users/archive-2004-03/0488.shtml
for details.
If you allow anonymous write access to the repository via Apache,
the Apache server never challenges the SVN client for a username, and
instead permits the write operation without authentication. Since
Subversion has no idea who did the operation, this results in a log
like this:
$ svn log
------------------------------------------------------------------------
rev 24: (no author) | 2003-07-29 19:28:35 +0200 (Tue, 29 Jul 2003)
See the Subversion Book ("Networking a Repository")
to learn about configuring access restrictions in Apache.
These appear to be due to the various Windows services that monitor
the filesystem for changes (anti-virus software, indexing services, the
COM+ Event Notification Service). This is not really a bug in Subversion,
which makes it difficult for us to fix. A summary of the current state of
the investigation is available here.
A workaround that should reduce the incidence rate for most people was
implemented in revision 7598; if you have an earlier version, please
update to the latest release.
This is usually due to a lack of available entropy on the system.
You probably need to configure the system to gather entropy from
sources such as hard-disk and network interrupts. Consult your system
manpages, specifically random(4) and rndcontrol(8) on how to effect
this change.
It means your httpd.conf is misconfigured. Usually this error happens
when you've defined the Subversion virtual "location" to exist within
two different scopes at the same time.
For example, if you've exported a repository as <Location
/www/foo>, but you've also set your DocumentRoot to
be /www, then you're in trouble. When the request comes in
for /www/foo/bar, apache doesn't know whether to find a
real file named /foo/bar within your
DocumentRoot, or whether to ask mod_dav_svn to fetch a file
/bar from the /www/foo repository. Usually the
former case wins, and hence the "Moved Permanently" error.
The solution is to make sure your repository
<Location> does not overlap or live within any
areas already exported as normal web shares.
A nice feature of Subversion is that the repository understands
copies and renames, and preserves the historical connections. For
example, if you copy /trunk to /branches/mybranch,
then the repository understands that every file in the branch has a
"predecessor" in the trunk. Running svn log --verbose will
show you the historical copy, so you can see the rename:
r7932 | joe | 2003-12-03 17:54:02 -0600 (Wed, 03 Dec 2003) | 1 line
Changed paths:
A /branches/mybranch (from /trunk:7931)
Unfortunately, while the repository is aware of copies and renames,
almost all the svn client subcommands are not aware. Commands
like svn diff, svn merge, and svn cat ought
to understand and follow renames, but don't yet do this. It's
scheduled as post-1.0 feature, currently issue
#1093. For example, if you ask svn diff to compare two
earlier versions of /branches/mybranch/foo.c, the command
will not automatically understand that the task actually requires
comparing two versions of /trunk/foo.c, due to the rename.
Instead, you'll see an error about how the branch-path doesn't exist
in the earlier revisions.
The workaround for all problems of this sort is to do the legwork
yourself. That is: you need to be aware of any renamed paths,
discover them yourself using svn log -v, and then provide
them explicitly to the svn client. For example, instead of
running
$ svn diff -r 1000:2000 http://host/repos/branches/mybranch/foo.c
svn: Filesystem has no item
svn: '/branches/mybranch/fooc..c' not found in the repository at revision 1000
...you would instead run
$ svn diff -r1000:2000 http://host/repos/trunk/foo.c
...
This is probably due to a known bug in Apache HTTP Server (versions
2.0.48 and earlier), for which a patch is available, see
http://nagoya.apache.org/bugzilla/show_bug.cgi?id=25040. You
may also want to read over
http://subversion.tigris.org/issues/show_bug.cgi?id=1608
to see if the description there matches your symptoms.
Adding -qlanglvl=extended to the
environment variable CFLAGS for configuration and build
will make xlc a bit more flexible and the code should
compile without error. See
http://svn.haxx.se/dev/archive-2004-01/0922.shtml and
its associated thread for more details.
See issue
695. The current implementation of svn checkout -N is
quite broken. It results in a working copy which has missing entries,
yet is ignorant of its "incompleteness". Apparently a whole bunch of
CVS users are fairly dependent on this paradigm, but none of the
Subversion developers were. For now, there's really no workaround
other than to change your process: try checking out separate
subdirectories of the repository and manually nesting your working
copies.
The error message in this case is a little misleading. Most likely
Apache is unable to load one or more DLLs that mod_dav_svn.so
relies on. If Apache is running as a service it will not have the
same PATH as a regular user. Make sure that
libdb4*.dll, libeay32.dll and ssleay32.dll
are present in either \Apache\bin or
\Apache\modules. You can copy them from your Subversion
installation directory if they are not there.
If this still does not resolve the problem, you should use a tool
like Dependency Walker
on mod_dav_svn.so to see if there are any other unresolved
dependencies.
They're supposed to invoke external programs, but the invocations
never seem to happen.
Before Subversion calls a hook script, it removes all
variables -- including $PATH on Unix, and %PATH% on Windows
-- from the environment. Therefore, your script can only
run another program if you
spell out that program's absolute name.
Debugging tips:
If you're using Linux or Unix, try running the script "by hand", by
following these steps:
- Use "su", "sudo", or something similar, to become the user who
normally would run the script. This might be httpd or
www-data, for example, if you're using Apache;
it might be a user like svn if you're running
svnserve and a special Subversion user exists. This
will make clear any permissions problems that the script
might have.
-
Invoke the script with an empty environment by using the
the "env" program. Here's an
example for the post-commit hook:
$ env - ./post-commit /var/lib/svn-repos 1234
Note the first argument to "env" is a dash; that's what
ensures the environment is empty.
-
Check your console for errors.
When using an external diff command, subversion builds a fairly
complicated command line. First is the specified --diff-cmd. Next comes
the specified --extensions (although empty --extensions are ignored), or
'-u' if --extensions is unspecified (or specified as ''). Third and
fourth, Subversion passes a '-L' and the first file's label (e.g.
"project_issues.html (revision 11209)"). Fifth and sixth are another
'-L' and the second label. Seventh and eighth are the first and second
file names (e.g. ".svn/text-base/project_issues.html.svn-base" and
".svn/tmp/project_issues.html.tmp").
If your preferred diff command does not support these arguments, you
may need to create a small wrapper script to discard arguments and just
use the last couple file paths.
Warning: Beware that Subversion does not expect the external diff
program to change the files it receives, and doing so may scramble the
working copy.
For further information, see issue
#2044.
Calm down, take a deep breath.
First of all, notice that the directory which contains the cached
passwords (usually ~/.subversion/auth/ on Unix systems) has permissions
of 700, meaning only you can read them. Trust your OS to protect data
on disk.
Secondly, if you're really worried, you can permanently turn off
password caching. With an svn 1.0 client, just set 'store-auth-creds
= no' in your run-time config file. With an svn 1.1 client or later,
you can use the more narrowly-defined 'store-passwords = no' (so that
server certs are still cached.)
Lastly, we point out that CVS has been caching passwords for years
in the .cvspass file. It may look like the passwords in .cvspass are
encrypted, but in fact they're only lightly scrambled with an
algorithm that's the moral equivalent to rot13. They can be cracked
instantly. The only utility of the the scrambling is to prevent users
(like root) from accidentally seeing the password. Nobody's cared
enough to to do this for Subversion yet; if you're interested, send
patches to the dev@ list.
Berkeley DB 4.1 has shown itself to be rather unstable - both 4.0
and 4.2 are better. This error message is a symptom of one unique way
in which 4.1 will sometimes break.
The problem is that the database format field for one of the tables
that make up a Subversion BDB-type repository has become corrupted.
For unknown reasons, this is almost always the 'copies' table, which
switches from the 'btree' type to the 'recno' type. Simple recovery
procedures are outlined below - if they do not succeed, you should
contact the Subversion Users mailing list.
- Ensure that no other processes will attempt to access your
repository.
- Now, back up your repository to a tar or zip file or
similar.
- Change to the db subdirectory of your repository.
- rm __db.* log.*
- db_dump -p -r copies > copies.dump
- Now edit copies.dump. In the section near the top,
change "type=recno" to "type=btree", and delete
the line beginning "re_len=".
- rm copies
- db_load copies < copies.dump
- svnadmin dump .. > ../../my-recovered.svndump
- Now create a new repository, reload the dump file just produced,
and copy across any custom hooks or configuration. Verify that the
highest revision number in the new repository is what you think it
should be.
Early versions of APR on its 0.9 branch, which Apache 2.0.x and
Subversion 1.x use, have no support for copying large files (2Gb+).
A fix which solves the 'svnadmin hotcopy' problem has been applied and
is included in APR 0.9.5+ and Apache 2.0.50+. The fix doesn't work
on all platforms, but works on Linux.
Assume you run 'svn checkout' on a repository and
receive a working copy at revision 7 (aka, r7) with one file in it
called foo.c. You modify the file and commit it
successfully. Two things happen:
- The repository moves to r8 on the server.
- In your working copy, only the file foo.c moves to r8.
The rest of your working copy remains at r7.
You now have what is known as a mixed revision working copy.
One file is at r8, but all other files remain at r7 until they too are
committed, or until 'svn update' is run.
$ svn -v status
7 7 nesscg .
8 8 nesscg foo.c
$
If you run the 'svn log' command without any
arguments, it prints the log information for the current directory
(named '.' in the above listing). Since the directory itself
is still at r7, you do not see the log information for r8.
To see the latest logs, do one of the following:
- Run 'svn log -rHEAD'.
- Run 'svn log URL', where URL is the repository URL.
- Ask for just that file's log information, by running
'svn log foo.c'.
- Update your working copy so it's all at r8, then run
'svn log'.
Normally one can simply run svnadmin recover to upgrade a
Berkeley DB repository in-place. However, due to a bug in the way
this command invokes the db_recover() API, this won't work
correctly when upgrading from BDB 4.0/4.1/4.2 to BDB 4.3.
Use this procedure to upgrade your repository in-place to BDB 4.3:
- Make sure no process is accessing the repository (stop
Apache, svnserve, restrict access via file://, svnlook, svnadmin,
etc.)
- Using an older svnadmin binary (that is, linked to
an older BerkeleyDB):
- Recover the
repository: 'svnadmin recover /path/to/repository'
- Make a backup of the repository.
- Delete all unused log files. You can see them by running
'svnadmin list-unused-dblogs /path/to/repeository'
- Delete the shared-memory files. These are files in the
repository's db/ directory, of the form __db.00*
The repository is now usable by Berkeley DB 4.3.
Developer questions:
Test execution can be dramatically sped up by keeping Subversion
test data on a RAM disk. On a Linux system, add lines like the
following in your /etc/fstab file:
tmpfs /home/brane/svn/obj-sh/subversion/tests tmpfs defaults,user,noauto,exec,size=64m
tmpfs /home/brane/svn/obj-st/subversion/tests tmpfs defaults,user,noauto,exec,size=64m
The minimum required size for testing ramdisk is approximately 700MB.
However, flagging your test targets for cleanup dramatically reduces
the space requirements (as shown in the example configuration above),
and thus your memory usage. Cleanup means more I/O, but since test
data is in-memory, there will be no performance degradation. Example:
make check CLEANUP=true
See http://svn.haxx.se/dev/archive-2003-02/0068.shtml for the
original authoritative discussion on use of RAM disks.
References:
The following email says it all. As the author points out,
Subversion does not actually use all of these WebDAV/DeltaV methods
yet, but it probably will someday, so if you're configuring a proxy,
you might as well allow all of them:
From: Nuutti Kotivuori <naked@iki.fi>
Subject: Re: list of HTTP messages used by svn?
To: "Hamilton Link" <helink@sandia.gov>
Cc: dev@subversion.tigris.org
Date: Sat, 10 Aug 2002 13:51:52 +0300
Hamilton Link wrote:
> Is there a full list of the HTTP methods svn uses somewhere, that
> someone could piont me to? From the documentation I can find (in
> particular project_faq.html and INSTALL), the list of methods svn
> uses include at least the following:
>
> GET, PROPFIND, REPORT, OPTIONS, MERGE, MKACTIVITY, and CHECKOUT
>
> But since the lists I can find are only partial lists and nowhere
> does it suggest these are all the ones used, I'm reluctant to make
> any assumptions.
>
> If I had a complete list, I could go to the corp. proxy guy once
> instead of many times, and reduce the risk of pissing him off and
> being left with inadequate svn support in the proxy.
http://www.webdav.org/deltav/WWW10/deltav-intro.htm
A list copied from there:
HTTP/1.1: GET, HEAD, POST, PUT, DELETE, OPTIONS, TRACE, CONNECT
WebDAV: LOCK, UNLOCK, PROPFIND, PROPPATCH, COPY, MOVE, MKCOL
DeltaV: CHECKIN, CHECKOUT, UNCHECKOUT, VERSION-CONTROL, REPORT,
UPDATE, LABEL, MERGE, MKWORKSPACE, BASELINE-CONTROL, MKACTIVITY
Subversion uses no methods outside these. It doesn't use all of them
either, but it's better to support the full WebDAV/DeltaV than just
some arbitrary subset. If the proxy being configured is a recent
Squid, it probably has everything from HTTP/1.1 and WebDAV - and then
it only needs the DeltaV extensions added.
You can give that list to your corp. proxy guy and explain to him that
he can check the RFC's for further information.
See Poul-Henning Kamp's post to freebsd-hackers: http://www.freebsd.org/doc/en_US.ISO8859-1/books/faq/misc.html#BIKESHED-PAINTING.
Throughout subversion's source code there are many references to
'baton' objects. These are just void * datastructures that
provide context to a function. In other APIs, they're often called
void *ctx or void *userdata Subversion
developers call the structures "batons" because they're passed around
quite a bit.
wedged repository:
A Subversion repository consists of two different internal parts, a
working compartment and a storage compartment. A wedged repository is
a repository where the working compartment is unaccessible for some
reason, but the storage compartment is intact. Therefore, a wedged
repository has not suffered any loss of data, but the working
compartment has to be corrected before you can access the
repository. See this entry for details
how to do that.
corrupted repository:
A corrupted Subversion repository is a repository where the storage
compartment has been damaged, and therefore there is some degree of
real data loss in the repository.
You might also like to check The Jargon File's definition for
'wedged'.