在ubuntu 下安装使用 Subversion

使用Subclipse时, Client要选择SVNKit(Pure Java)，不要选Java HL(JNI)，后者兼容性不佳

sudo apt-get install subversion
sudo mkdir /home/svn
cd /home/svn

sudo mkdir testsvn
sudo svnadmin create /home/svn/testsvn  新建一个名为testsvn的资源库

(如果有eclipse项目A，项目B，那么项目A和B，是testsvn资源库的下属，这点和以前的理解不一样)

cd /home
sudo groupadd svn 新建svn组
sudo usermod -a -G svn neo 把neo加到svn组成员中去
sudo chgrp -R svn /home/svn 递归将svn及其子目录/文件的组拥有者设置成svn组
sudo chmod -R g+w /home/svn 递归将svn及其子目录/文件的组拥有者(svn)赋予w的权限(是否应该递归,会不会影响安全?)

sudo gedit /home/svn/passwd-team 创建密码文件
内容如下：
[users]
michal = somepassword
jimmy = anotherpassword
craig = yetanotherpassword

由于这个密码文件是明码保存的,所以设置成只有root可以访问
sudo chmod 600 /home/svn/passwd-team

编辑svnserve.conf这个文件
gedit /home/svn/testsvn/conf/svnserve.conf
改成
[general]
anon-access = none  设置不允许匿名访问
password-db = /home/svn/passwd-team
realm = Team

注意，以上参数名称, 必须在每行的顶头写，前面不能有空格。比如anon-access前如果加了空格，则svn会提示"svn: /home/svn/upos/conf/svnserve.conf:12: Option expected"

(也可以一个项目使用一个密码文件, 在每个项目的conf目录下,有passwd和authz两个示例, 前者是密码文件,后者是组权限文件,可以设置某个用户组是只读还是读写权限, 以下文档写的比较详细 http://blog.sina.com.cn/s/blog_3eba8f1c0100dqk1.html）

启动subversion
sudo svnserve -d --foreground -r /home/svn/  --foreground表示以前台形式运行，可以按Ctrl+C终止subversion的服务
可以在桌面上建立一个运行在Application Terminate中的Luncher，command是sudo svnserve -d --foreground -r /home/svn/

访问svn
svn checkout svn://127.0.0.1/testsvn --username jimmy 会提示输入密码
在Eclipse中，使用svn://127.0.0.1/testsvn的URL，会提示用户名和密码

-------------------------------------------------------------------------------

以下是参考文档

原文在http://odyniec.net/articles/ubuntu-subversion-server/

附件是启动脚本, 需根据实际情况修改

Setting Up an Ubuntu Subversion Server

This tutorial describes setting up a Subversion server on an Ubuntu system and configuring it for use by a group of developers. The goal is to allow each member of a development team to access the Subversion repositories from a remote location (e.g., a workstation at home), using either the svn or svn+ssh protocol.

Prerequisites

It is assumed that you already have a basic Ubuntu server running, and that the other developers can connect to it. If you want to allow them to access the Subversion server with the secure svn+ssh protocol, then each developer must also be able to login to your machine with SSH.

Basic Subversion Setup

Begin by installing the Subversion package:

$ sudo apt-get install subversion

You're going to need a directory for your repositories, as well as other Subversion-related files. Most people use /home/svn or /usr/local/svn for this purpose, and you can choose either. I personally prefer /usr/local/svn over /home/svn , as I like to keep /home for home directories of real users of the system.

$ sudo mkdir /usr/local/svn

Inside this directory, create another one to hold your repositories:

$ sudo mkdir /usr/local/svn/repos

Now, you need to set some access permissions on those directories. You only want to allow certain users of your system (that is, yourself and the other developers) to access the repositories, so add a new group for those users. Name the group svn .

$ sudo groupadd svn

Then, change the group ownership of /usr/local/svn/repos to the new group using the chgrp command:

$ sudo chgrp svn /usr/local/svn/repos

The members of the svn group also need write access to the repos directory, so use chmod to add the write permission for the group:

$ sudo chmod g+w /usr/local/svn/repos

Additionally, you need to make sure that all new files and directories created in the repos directory (in other words, anything committed to the repositories) will also be owned by the group. To accomplish this, use chmod again to set the set-group-ID bit on the directory, which causes any file created inside it to have the same group ownership as the directory itself. Effectively, everything in repos will belong to the svn group.

$ sudo chmod g+s /usr/local/svn/repos

OK, so you now have the repositories directory with proper permissions, ready to be used by the svn group. Go ahead and add yourself to the group:

$ sudo usermod -a -G svn michal

However, your new group membership will not be effective for the current session, so you need to log out and log back in. When you're back, you can verify that your account is recognized as a member of the svn group:

$ groups michal adm dialout cdrom plugdev lpadmin admin sambashare svn

If the other developers have user accounts on your server, add them to the group too:

$ sudo usermod -a -G svn jimmy $ sudo usermod -a -G svn craig

If they don't, they will still be able to access the repositories, but only using the basic svn protocol, not the secure svn+ssh method.

Creating a Test Repository

You can now create a repository. In the following steps, I'll demonstrate how to create a simple test repository containing one text file, and how to check out and commit files. If you're not familiar with Subversion, then this could be a good exercise to learn the basics. Otherwise, you can skip all the test checkouts and commits and just create the repository for your project.

The repository will be a subdirectory in the repos directory, and will have its group ownership set to svn (thanks to the chmod g+s you did earlier). However, that's not all – you also need to make sure the repository will be group writable, so that the other members of the svn group will be able to commit files. To do this, set the umask to 002 :

$ umask 002

This command sets the new file mode creation mask which controls the default permissions of any new file that you create. The default value is 022 and it corresponds to read/write permissions for the file owner, and read permissions for the group and others. The new value, 002 , also gives write permissions to the group, which is just what you need.

Create the repository using the svnadmin command:

$ svnadmin create /usr/local/svn/repos/test

And set back the default umask:

$ umask 022

So you now have an empty repository, waiting for you to commit something to it. But, before you do this, you need to check out the current version (i.e., the empty directory) to create a working copy.

$ svn checkout file:///usr/local/svn/repos/test Checked out revision 0.

The working copy has been checked out to a new directory named test . Go ahead and create a simple "hello world" text file in that directory:

$ cd test $ echo 'Hello, World!' > hello.txt

Then, add it to version control with the svn add command:

$ svn add hello.txt A         hello.txt

Finally, commit it using svn commit :

$ svn commit -m "Added a 'hello world' text file." Adding         hello.txt Transmitting file data . Committed revision 1.

The hello.txt file is now in the repository.

Accessing the Repository with the Svn Protocol

Remote repository access with the svn protocol requires you to use svnserve , a Subversion server program. Each repository has a svnserve configuration file (stored in the conf subdirectory) which controls how the repository can be accessed with svnserve .

First, create a passwords file that lists the users of the repository and their passwords. This will be a common passwords file for your development team and you will be able to use it with multiple repositories.

$ sudo gedit /usr/local/svn/passwd-team

Here's a sample passwords file. Each line (except the first one, which is the configuration section name) defines a user name and the corresponding password.

[users] michal = somepassword jimmy = anotherpassword craig = yetanotherpassword

Since the passwords are stored unencrypted, it's important that you protect the passwords file by setting the proper permissions. The file should not be readable by anyone except the owner (which is root ), so change its mode to 600 :

$ sudo chmod 600 /usr/local/svn/passwd-team

Then, open the svnserve configuration file in the test repository:

$ gedit /usr/local/svn/repos/test/conf/svnserve.conf

There's probably some default configuration in the file, but you can just remove everything and enter this:

[general] anon-access = none password-db = /usr/local/svn/passwd-team realm = Team

The anon-access = none line denies access to the repository to unauthenticated users (by default, they are allowed read access, so they can do checkouts). The password-db setting tells svnserve where to look for the passwords file when authenticating users, and the realm setting defines the name of the authentication realm.

OK, the configuration is ready, so you can now launch svnserve .

$ sudo svnserve -d --foreground -r /usr/local/svn/repos

The command-line options tell svnserve to run in daemon mode (-d ) as a foreground process (--foreground ), and to look for repositories in the repos dir that was created earlier (-r /usr/local/svn/repos ). Normally the program should be running in the background (that's what daemon processes do), but at this moment you only need to test it, so it's more convenient to run it in the foreground, where you can easily kill it with Ctrl +C .

Now, try accessing the repository using the svn protocol. You can try it on another machine over the network, or on the same computer (in another terminal). In the latter case, make sure you're not doing the checkout in the same directory where the previous test working copy was checked out, because it won't work – either delete the test directory, or cd to some other location.

Enter the following svn checkout command, replacing 192.168.10.11 with the IP address of your Subversion server (if you're testing on the same machine, you can use 127.0.0.1 ):

$ svn checkout svn://192.168.10.11/test --username jimmy

The server will ask you for password:

Authentication realm: <svn://192.168.10.11:3690> Team Password for 'jimmy':

Then, it proceeds with the checkout.

A    test/hello.txt Checked out revision 1.

And there's your working copy. Now, check if it works the other way – try modifying the file and committing it back to the repository. Open hello.txt with a text editor and add some text:

$ cd test $ gedit hello.txt

When you're done, commit it:

$ svn commit -m "Modified the hello.txt file." Sending        hello.txt Transmitting file data . Committed revision 2.

Sweet, it works both ways.

Accessing the Repository with the Svn+SSH Protocol

Setting up your Subversion server for svn+ssh access is simple, as it doesn't even require using the svnserve program. Assuming you have a SSH server running on the Subversion machine, and the other developers can login to it, you don't have to configure anything – just set up the repository.

You can just go ahead and check out the test project. The checkout operation is slightly different with the svn+ssh access method. First, you must specify the full path to the repository in the checkout URL:

$ svn checkout svn+ssh://192.168.10.11/usr/local/svn/repos/test --username jimmy

Then, when the server asks you for a password, you need to enter the user's SSH password, not the one from the passwd-team file.

[email protected]'s password:

And there it goes:

A test/hello.txt Checked out revision 2.

From here, you can use your working copy the same way as with the svn protocol.

Svnserve Initialization Script

If you plan on using svnserve in the long run, you probably don't want to start it from the command-line every time the server is rebooted. The proper way to start system services is with init scripts located in the /etc/init.d directory.

The Subversion package for Ubuntu does not include an init script, so you have to make one yourself. Or, you can download this init script , written by yours truly. Save the script as /etc/init.d/svnserve and make it executable:

$ sudo chmod +x /etc/init.d/svnserve

If you chose anything other than /usr/local/svn/repos for the repositories directory, make sure to change the path in the init script.

Run update-rc.d to install the script:

$ sudo update-rc.d svnserve defaults Adding system startup for /etc/init.d/svnserve ... /etc/rc0.d/K20svnserve -> ../init.d/svnserve /etc/rc1.d/K20svnserve -> ../init.d/svnserve /etc/rc6.d/K20svnserve -> ../init.d/svnserve /etc/rc2.d/S20svnserve -> ../init.d/svnserve /etc/rc3.d/S20svnserve -> ../init.d/svnserve /etc/rc4.d/S20svnserve -> ../init.d/svnserve /etc/rc5.d/S20svnserve -> ../init.d/svnserve

And that's it – svnserve will be started automatically when your system boots up. To start it manually, run this command:

$ sudo /etc/init.d/svnserve start

 

另外一篇 http://blog.sina.com.cn/s/blog_3eba8f1c0100dqk1.html

一、SVN安装
1.安装包
$ sudo apt-get install subversion

2.添加svn管理用户及subversion组
$ sudo adduser svnuser
$ sudo addgroup subversion
$ sudo addgroup svnuser subversion 

      

3.创建项目目录
$ sudo mkdir /home/svn
$ cd /home/svn
$ sudo mkdir fitness
$ sudo chown -R root:subversion fitness
$ sudo chmod -R g+rws fitness

4.创建SVN文件仓库
$ sudo svnadmin create /home/svn/fitness

5.访问方式及项目导入：
$ svn co file:///home/svn/fitness
或者
$ svn co file://localhost/home/svn/fitness
* 注意：
如果您并不确定主机的名称，您必须使用三个斜杠(///)，而如果您指定了主机的名称，则您必须使用两个斜杠(//).
//--
下面的命令用于将项目导入到SVN 文件仓库：
$ svn import -m "New import" /home/svn/fitness file:///home/svnuser/src/fitness
一定要注明导入信息

//--------------------------//
6.访问权限设置
修改 /home/svn/fitness目录下：
svnserve.conf 、passwd 、authz三个文件,行最前端不允许有空格
//--
编辑svnserve.conf文件,把如下两行取消注释
password-db = password
authz-db = authz

//补充说明
# [general]
anon-access = read
auth-access = write
password-db = passwd
其中 anon-access 和 auth-access 分别为匿名和有权限用户的权限，默认给匿名用户只读的权限,但如果想拒绝匿

名用户的访问，只需把 read 改成 none 就能达到目的。

//--
编辑/home/svnuser/etc/passwd  如下:
[users]
mirze = 123456
test1 = 123456
test2 = 123456
//--
编辑/home/svnuser/etc/authz如下
[groups]
admin = mirze,test1
test = test2
[/]
@admin=rw
*=r
这里设置了三个用户mirze,test1,test2密码都是123456
其中mirze和test1属于admin组，有读和写的权限,test2属于test组只有读的权限

7.启动SVN服务
svnserve -d -r /home/svn
描述说明：
-d 表示svnserver以“守护”进程模式运行
-r 指定文件系统的根位置（版本库的根目录），这样客户端不用输入全路径，就可以访问版本库
如: svn://192.168.12.118/fitness

这时SVN安装就完成了.
局域网访问方式：
例如：svn checkout svn://192.168.12.118/fitness --username mirze --password 123456 /var/www/fitness


-----------------------------------------------------------------------

二、HTTP:// [apache]
1.安装包 [已安装subversion]
$ sudo apt-get install libapache2-svn

创建版本仓库：
sudo svnadmin create /目录地址
目录地址必须存在，这个就是保存版本仓库的地方，不同的版本仓库创建不同的文件夹即可，比如：
sudo svnadmin create /home/svn/project
本来/home/svn/project这个目录下什么都没有，执行下面的命令之后再去看一下，多出一些文件和文件夹，我们需要操作的是conf这个文件夹，这个文件夹下有一个文件，叫做passwd，用来存放用户名和密码。
然后把这个版本仓库目录授权给apache读写：
sudo chown -R www-data:www-data /目录地址
然后来到打开apache配置文件：
sudo gedit /etc/apache2/mods-available/dav_svn.conf

加入如下内容：
<Location /project>
DAV svn
SVNPath /home/svn/project
AuthType Basic
AuthName “myproject subversion repository”
AuthUserFile /home/svn/project/conf/passwd
#<LimitExcept GET PROPFIND OPTIONS REPORT>
Require valid-user
#</LimitExcept>
</Location>

location说的是访问地址，比如上述地址，访问的时候就是
http://127.0.0.1/project
其中有两行被注释掉了，以保证每次都需要用户名密码。
最后一步就是创建访问用户了，建议将用户名密码文件存放在当前版本仓库下conf文件夹下，这样版本仓库多的时候无至于太乱。
因为conf文件夹下已经存在passwd文件了，所以直接添加用户：
sudo htpasswd -c /home/svn/project/conf/passwd test
然后输入两遍密码，laoyang这个用户就创建好了。
打开/home/svn/project/conf/passwd这个文件，会开到形如如下形式的文本：
test:WEd.83H.gealA  //后面是加密后的密码。
创建以后，再次需要往别的版本仓库添加这个用户，直接把这一行复制过去就可以了。
重启apache就可以了。
sudo /etc/init.d/apache2 restart


-----------------------------------------------------------------------

三、同步更新 [勾子]

同步程序思路 ：用户提交程序到SVN，SVN触发hooks,按不同的hooks进行处理，这里用到的是post-commit，利用post-commit到代码检出到SVN服务器的本地硬盘目录，再通过rsync同步到远程的WEB服务器上。

知识点：
1、SVN的hooks
# start-commit 提交前触发事务
# pre-commit 提交完成前触发事务
# post-commit 提交完成时触发事务
# pre-revprop-change 版本属性修改前触发事务
# post-revprop-change 版本属性修改后触发事务
通过上面这些名称编写的脚本就就可以实现多种功能了，相当强大。
2、同步命令rsync的具体参数使用
3、具有基个语言的编程能力bash python perl都可以实现

post-commit具体实现细节
post-commit脚本

 编辑文件：sudo vim /home/svn/fitness/hooks/post-commit

注意：编辑完成post-commit后，执行：sudo chmod 755 post-commit

内容：

#!/bin/sh
export LANG=zh_CN.UTF-8
sudo /usr/bin/svn update /var/www/www --username mirze --password 123456

或

#Set variable
SVN=/usr/bin/svn
WEB=/home/test_nokia/
RSYNC=/usr/bin/rsync
LOG=/tmp/rsync_test_nokia.log
WEBIP="192.168.0.23"
export LANG=en_US.UTF-8
 
#update the code from the SVN
$SVN update $WEB --username user --password  password
#If the previous command completed successfully, to continue the following
if [ $? == 0 ]
then
    echo ""     >> $LOG
    echo `date` >> $LOG
    echo "##############################" >> $LOG
    chown -R nobody:nobody /home/test_nokia/
    #Synchronization code from the SVN server to the WEB server, notes:by the key
    $RSYNC -vaztpH  --timeout=90   --exclude-from=/home/svn/exclude.list $WEB root@$WEBIP:/www/ >> $LOG
fi

以上是具体的post-commit程序
注意事项：
1、一定要定义变量，主要是用过的命令的路径。因为SVN的考虑的安全问题，没有调用系统变量，如果手动执行是没有问题，但SVN自动执行就会无法执行了。
2、SVN update 之前一定要先手动checkout一份出来，还有这里一定要添加用户和密码 如果只是手动一样会更新，但自动一样的不行。
3、加上了对前一个命令的判断，如果update的时候出了问题，程序没有退出的话还会继续同步代码到WEB服务器上，这样会造成代码有问题
4、记得要设置所属用户，因为rsync可以同步文件属性，而且我们的WEB服务器一般都不是root用户，用户不正确会造成WEB程序无法正常工作。
5、建议最好记录日志，出错的时候可以很快的排错
6、最后最关键的数据同步，rsync的相关参数一定要清楚，这个就不说了。注意几个场景：
这里的环境是SVN服务器与WEB服务器是开的
把SVN服务器定义为源服务器 WEB服务器为目的服务器
场景一、如果目的WEB服务器为综合的混杂的，像只有一个WEB静态资源，用户提交的，自动生成的都在WEB的一个目录下，建议不要用–delete这个参数
上面这个程序就是这样，实现的是源服务器到目的服务器的更新和添加，而没有删除操作，WEB服务器的内容会多于源SVN的服务器的
场景二、实现镜像，即目的WEB服务器与源SVN服务器一样的数据，SVN上任何变化WEB上一样的变化，就需要–delete参数
场景三、不需要同步某些子目录，可能有些目录是缓存的临时垃圾目录，或者是专用的图片目录（而不是样式或者排版的）要用exclude这个参数
注意：这个参数的使用不用写绝对路径，只要目录名称就行 aa代表文件 aa/ 代表目录 ，缺点就是如果有多个子目录都是一样的名称 那么这些名称就都不会被同步
建议用–exclude-from=/home/svn/exclude.list 用文件的形式可以方便的添加和删除
exclude.list

.svn/
.DS_Store
images/

利用SVN的钩子还可以写出很多的程序来控制SVN 如代码提交前查看是否有写日志，是否有tab，有将换成空格，是否有不允许上传的文件，是否有超过限制大小的文件等等。