Some Helpful Subversion (SVN) general repository
managing commands when you have to deal with Subversion on Debian
Lenny servers
When I started with subversion it was a bit chaotic for me to grasp
the subversion repository software basics.
Since I know there are many other people like me who are a novice
into suversion I decided to post few of the
life saving (vital) subversion commands, I learned and use quite
often this days.
This post should be considered as a very very overview of
subversion commands. For more information please check,
The subversion red-bean book
here .
So here we go:
1. First To create repository after installing subversion you
need to execute something similar to:
debian-server:~# svnadmin create --fs-type fsfs
/path/to/repos/repo
In the above example
/path/to/repos is actually the path to
where you store the svn repositories, and
repo is actually
the repository name.
By the way note that by default svnadmin would create the
repository in the fsfs database format, even if you skip the,
fsfs option.
2. Let's say you want to import some code into the
newly created repository located in /path/to/repo via the local
filesystem.
Here is how:
# imports in the subversion repository debian-server:~# svn
import -m "importing directory in svn over local filesystem"
\
~/directory_to_import/ files:///path/to/repos/repo/trunk
In the forementioned example the,
-m and the following text:
"importing directory in svn over local filesystem"
is for description of the importing data,
the
~/directory_to_import/ is the directory you prefer to
import into the local repository, the code left,
files:///path/to/repo/trunk specifies that you want to
import the data into the repository subdirectory
"trunk".
Then again let's assume that you want to achieve a file import into
a newly created repository through
ssh + the apache
mod_dav_svn
It's pretty easy the above should be changed to:
debian-server:~# svn import -m "importing directory in svn
over mod_dav_svn e.g. (svn+ssh)" \
~/directory_to_import/
svn+ssh://user@host/path/to/repos/repo/trunk
of course
it preliminary that you input a proper
user and
host or
ip address as you have previously configured the mod_dav_svn,
then again svn+ssh specifies the protocol type.
Now as we have imported our program source code into the
repository, next it's important to checkout the code to have a
current copy of the source code.
3. To checkout code already existing in some repository in your
subversion server via (svn+ssh) protocol, you need to execute some
command similar to:
debian-server:~# svn co
svn+ssh://user@host/path/to/repos/repo/trunk
~/checkout_into_directory/
Here again as a first protocol argument
(svn+ssh://) it's
necessery to enter
path/to/repos/repo/trunk and as a second
argument to
gsvn (the subversion command line client
interface) we put
~/checkout_into_directory/ , it's
a nice idea to to create the checkout_into_directory
beforehead.
Now if we have to checkout the code after we've been logged in the
system and the repository database is locally stored on the same
server as we are, we have to execute:
debian-server:~# svn co files://path/to/repos/repo/trunk
~/checkout_into_directory/
Take a note that in the example above I use the root user but
possibly you would choose a non-privileged user, therefore you
should have properly set both physical user account permissons on
the subversion repository database
(e.g. chown your
/path/to/repos/repo/ and put your local user into the proper
/etc/groups).
Another truly precious command that you will probably need to use
on daily and hourly basis would probably be:
4. The listing of repository content cmd, in order to do that
while locally logged on the server with the svn repository
execute:
debian-server:~# svn list
file:///path/to/repos/repo/trunk
I believe the above command is self-explanatory enough, in case if
you plan to do file listing within the svn repository over
(ssh+svn) here is how:
debian-server:~# svn list --verbose
svn+ssh://user@host/path/to/repos/repo/trunk
Again, I won't take the time to explain since the logic in the
syntax is equal to the one exhibited beforehead.
5. Another handy thing to do with your subversion repository
content after checkout is the subversion source repository
update
the
svn update The checkout will enable you to
always synchronize your
~/checkout_into_directory to the
latest stable version of the code within your svn repository.
So after the first checkout it would be good idea to use
svn
update and update your repository project source tree.
So here is how:
debian-server:~# svn update
~/checkout_into_directory/
So now as I have shown most basic operations with subversion, Lest
important to show you is
6. How to delete source from a repository in
subversion.
In order to
delete some part from your subversion
repository project source from the local filesystem use:
debian-server:~# svn delete
files:///path/to/repos/repo/track/some_directory
This command would completely erradidacate
some_directory
from your example
repo. Yet if you desire to delete a file
specify a file instead of the some_directory
Now to accomplish the same delete operation via (svn+ssh) execute
something like:
debian-server:~# svn delete
svn+ssh://user@host/path/to/repos/repo/track/some_directory
Once again I won't bother to explain the above example code, cause
I believe it's clear enough for everybody to understand.
7. To reverse your project code to some stable release of your
source code existing in the repository you should use something
like:
debian-serve~:# svn checkout -r 4
files:///path/to/repos/repo/trunk
This would checkout the project source to it's 4th release from the
repository: repo
8. To commit code with changes in your subversion repository use a
command like:
debian-server:~# svn commit -m "Some description text"
some_directory/
The svn command line interface is also capable of svn copy and svn
rename in order to either,
copy or rename commited source, however I won't get into details on
that just experiment and you'll quickly master them.
9. Now one last thing I'm gonna tell you about is the subversion
svn info command and svn status . This really useful command should
be used to check information on your source tree after you have
either checked it out or have used svn update to
have the latest copy of it. This is an absolute necessity.
Here is how to check the information assigned about the version
release and some other useful info for your source tree.
debian-server:~# svn info ~/check_into_directory
or you might type svn info without arguments as well
debian-server:~# svn info
Yet another useful one on project status is:
debian-server:~# svn status