安装Subversion 服务

作者：Rock Sun, Subversion中文站。
 
 
以前的svnserve要想成为windows服务，必须依赖于svnservice或其他工具。从Subversion1.4开始，Subversion本身就集成Windows服务的工具。
1，安装svnservice
在Windows NT中（包括Windows XP, Windows 2000, Windows 2003 Server）本身包含了一个安装服务的工具，叫做"Service Control"，也就是sc.exe。
例如我的Subversion安装在"D:\Subversion"，版本库在"D:\svnroot"，而我希望对应的Subversion服务名为svnservice，安装这个svn服务的命令就可以这样写：
      sc create svnservice
      binpath= "D:\Subversion\bin\svnserve.exe --service -r D:\svnroot"
      displayname= "SVNService"
      depend= Tcpip
例如：
sc create Subversion_Service binPath= "\"D:\Program Files\Subversion\bin\svnserve.exe\" --service -r e:\svn\project" displayName= "SubversionService" depend= Tcpip

 
      
请注意，因为便于察看，上面的命令分为多行，但在实际执行时应该在一行里。另外，在以前启动svnserve时会使用"-d"选项，也就是守护进程模式，在这里不能使用，会导致服务无法启动。同样，"-i"和"-t"选项也不能使用。
在命令行窗口执行完这个命令之后，服务还没有启动，你可以继续运行"net start svnservice"启动这个服务，然后使用"net stop svnservice"停止服务。
另外还有两点需要小心处理。首先，如果路径中包括空格，一定要用“\”处理“"”号，例如上面的例子中如果svnserve.exe在“c:\ program files\subversion\”中，则命令应该写为“binpath= "\"c:\program files\subversion\bin\svnserve.exe\"”（“”中的内容），整个命令如下，红色部分是改变部分：
      sc create svnservice
      binpath= "\"D:\program files\Subversion\bin\svnserve.exe\" --service -r D:\svnroot"
      displayname= "SVNService"
      depend= Tcpip
      
其次，sc对选项的格式还有要求，例如“depend= Tcpip”不能写为“depend = Tcpip”或“depend=Tcpip”，也就是“=”前不能有空各，而后面必须有空格。

2，删除服务
如果服务安装的有问题，你可能需要删除服务。要删除前面添加的服务，只需要运行"sc delete svnservice"，"svnservice"就是我们创建服务时使用的名字。

3，配置服务是自动启动
默认情况下安装的服务不会随Windows的启动而启动，为了使svn服务能够随Windows启动而启动，需要修改一下"sc create"命令（首先要删除），增加"start= auto"选项：
      sc create svnservice
      binpath= "D:\Subversion\bin\svnserve.exe --service -r D:\svnroot"
      displayname= "SVNService"
      depend= Tcpip
      start= auto
      
当然你也可以使用图形化的工具修改服务的属性，你可以在“开始->运行...”中执行"services.msc"，然后在界面中修改。

Windows Service Support for svnserve
====================================

svnserve can now be run as a native Windows service.  This means that the
service can be started at system boot, or at any other time, without the
need for any wrapper code to start the service.  The service can be managed
like any other Windows service, using command-line tools ("net start",
"net stop", or sc.exe) or GUI tools (the Services administrative tool).


Installation
------------

For now, no means is provided to install the service.  Most Windows
OSes derived from Windows NT (such as Windows XP, Windows 2000,
Windows 2003 Server) provide a command-line tool for installing
services, called SC.EXE for "Service Control". To create a service for
svnserve, use SC.EXE:

   sc create <name>
      binpath= "c:\svn\bin\svnserve.exe --service <svn-args>"
      displayname= "Subversion Repository"
      depend= Tcpip

where <name> is any service name you want, e.g. "svnserve", and
<svn-args> are the arguments to svnserve, such as --root,
--listen-port, etc.  (All of this should be specified on a single
line, of course.)

In order for svnserve to run as a Windows service, you MUST specify
the --service argument, and you must NOT specify any other run mode
argument, such as --daemon, --tunnel, --inetd, or any of their short
forms.  There is no short form for --service.

If the path to svnserve.exe contains spaces or other characters that
must be escaped, then you must enclose the path to svnserve.exe with
double-quotes, which themselves must be quoted using a backslash.
Fortunately the syntax is similar to that on Unix platforms:

   sc create <name>
      binpath= "\"c:\program files\subversion\bin\svnserve.exe\" ..."

SC has many options; use "sc /?".  The most relevant are:

   sc create <name>     create a new service
   sc qc <name>         query config for a service
   sc query <name>      query status
   sc delete <name>     delete any service -- BE CAREFUL!
   sc config <name> ... update service config; same args as sc create
   sc start <name>      start a service (does NOT wait for completion!)
   sc stop <name>       stop a service (does NOT wait for it to stop!)

Note that the command-line syntax for SC is rather odd.  Key/value
pairs are specified as "key= value" (without the double-quotes).  The
"key=" part must not have any spaces, and the "value" part MUST be
separated from the "key=" by a space.

If you want to be able to see the command shell, add these arguments
to the "sc create" command-line:

   type= own type= interact

This sets the "interactive" bit on the service, which allows it to
interact with the local console session.

You can create as many services as you need; there is no restriction
on the number of services, or their names.  I use a prefix, like
"svn.foo", "svn.bar", etc.  Each service runs in a separate process.
As usual, it is your responsbility as an administrator to make sure
that no two service instances use the same repository root path, or
the same combination of --listen-port and --listen-host.


Uninstalling
------------

To uninstall a service, stop the service, then delete it, using "sc
delete <name>".  Be very careful with this command, since you can
delete any system service, including essential Windows services,
accidentally.

Also, make sure that you stop the service before you delete it.  If
you delete the service before stopping it, the Service Control Manager
will mark the service "deleted", but will intentionally not stop the
service.  The service will be deleted when the system reboots, or when
the service finally exits.  After all, you only asked to delete the
service, not to stop it.

That's all there is to it.


Automatically Starting Service on System Boot
---------------------------------------------

By default, SC creates the service with the start mode set to "demand"
(manual).  If you want the service to start automatically when the
system boots, add "start= auto" to the command line.  You can change
the start mode for an existing service using "sc config <name> start=
auto", or also by using the Windows GUI interface for managing
services.  (Start, All Programs, Administrative Tools, Services, or
just run "services.msc" from Start/Run or from a command-line.)

Note: In order for svnserve to start correctly on system boot, you
must properly declare its startup dependencies.  The Service Control
Manager will start services as early as it can, and if you do not
properly declare its startup dependencies, it can potentially start
before the TCP/IP stack has been started.  This is why you must
provide specify 'depend= Tcpip' to SC.EXE when creating the service.


Starting and Stopping the Service
---------------------------------

You start and stop the service like any other Windows service.  You
can use the command-line "net start <name>", use the GUI Services
interface.


Debugging
---------

Debugging a Windows service can be difficult, because the service runs
in a very different context than a user who is logged in.  By default,
services run in a "null" desktop environment.  They cannot interact
with the user (desktop) in any way, and vice versa.

Also, by default, services run as a special user, called LocalSystem.
LocalSystem is not a "user" in the normal sense; it is an NT security
ID (SID) that is sort of like root, but different.  LocalSystem
typically does NOT have access to any network shares, even if you use
"net use" to connect to a remote file server.  Again, this is because
services run in a different login session.

Depending on which OS you are running, you may have difficulty
attaching a debugger to a running service process.  Also, if you are
having trouble *starting* a service, then you can't attach to the
process early enough to debug it.

So what's a developer to do?  Well, there are several ways you can
debug services.  First, you'll want to enable "interactive" access for
the service.  This allows the service to interact with the local
desktop -- you'll be able to see the command shell that the service
runs in, see console output, etc.  To do this, you can either use the
standard Windows Services tool (services.msc), or you can do it using
sc.exe.

   * With the GUI tool, open the properties page for a service, and go
     to the "Log On" page.  Select "Local System account", and make
     sure the "Allow service to interact with desktop" box is checked.

   * With SC.EXE, configure the service using the command:

         sc <name> config type= own type= interact

     Yes, you must specify type= twice, and with exactly the spacing
     shown.

In both cases, you'll need to restart the service.  When you do, if
the service started successfully, you'll see the console window of the
service.  By default, it doesn't print anything out.

Next, you'll want to attach a debugger, or configure the service to
start under a debugger.  Attaching a debugger should be
straightforward -- just find the process ID.  But if you need to debug
something in the service startup path, you'll need to have a debugger
attached from the very beginning.  There are two ways to do this.

In the first method, you alter the command-line of the service (called
the "binary path").  To do this, use SC.EXE to set the binary path to
whatever debugger you are going to use.  I use the most recent version
of WinDbg, which is excellent, and is available at:

   http://www.microsoft.com/whdc/devtools/debugging/installx86.mspx

For example, this command would configure the service to start under a
debugger:

   sc config <name> binpath= "d:\dbg\windbg.exe -g -G d:\svn\bin\svnserve.exe
      --root d:\path\root --listen-port 9000"
      depend= Tcpip

The entire command must be on a single line, of course, and the binary
path must be in double-quotes.  Also, the spacing MUST be: binpath= "..."

Substitute whatever debugger you want, with whatever command-line you
want, in place of windbg.exe.  Then start the service (sc start
<name>), and the Service Control Manager should execute the
command-line you provided as the binary path.  Then your debugger
should start, and should launch the svnserve process.


Known Issues
------------

* No management tool (installer, etc.).  For the first version, this
  is intentional; we just want to get the service functionality tested
  and committed before dealing with installation.

* Right now, I don't know of a way to cleanly stop the svnserve
  process.  Instead, the implementation closes the listen socket,
  which causes the main loop to exit.  This isn't as bad as it sounds,
  and is a LOT better than other options (such as terminating a
  thread).


To Do
-----

* The support for running svnserve as a Windows service is complete,
  but there is still more work to be done for installing and managing
  services.