 ------
 SCM Implementation: CVS
 ------
 Wim Deblauwe
 ------
 2008-09-02
 ------

~~ Licensed to the Apache Software Foundation (ASF) under one
~~ or more contributor license agreements.  See the NOTICE file
~~ distributed with this work for additional information
~~ regarding copyright ownership.  The ASF licenses this file
~~ to you under the Apache License, Version 2.0 (the
~~ "License"); you may not use this file except in compliance
~~ with the License.  You may obtain a copy of the License at
~~
~~   http://www.apache.org/licenses/LICENSE-2.0
~~
~~ Unless required by applicable law or agreed to in writing,
~~ software distributed under the License is distributed on an
~~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~~ KIND, either express or implied.  See the License for the
~~ specific language governing permissions and limitations
~~ under the License.

~~ NOTE: For help with the syntax of this file, see:
~~ http://maven.apache.org/doxia/references/apt-format.html

SCM Implementation: CVS

* General Info

    Link : {{https://www.cvshome.org/}}

    License : GPL

* SCM Url

  The general format for a CVS SCM Url is

-------
scm:cvs<delimiter><method>[<delimiter>username_password_servername_port]<delimiter>path_to_repository<delimiter>module_name
-------

  As delimiter you can use either colon ':' or, if you use a colon for one
  of the variables (e.g. a windows path), a pipe '|'.

  The following methods are supported:

  * ext, connecting to a server using an external rsh program

  * local, connecting to the local file system

  * lserver, connecting to a local server

  * pserver, connecting to a password-authenticating server

  * sspi, secure authentication (less supported by clients and servers, may require using native implementation, for more details see "How to choose the CVS provider implementation")

  * sserver, SSL connection method for CVS (only if cvs_native is used i.e. using -Dmaven.scm.provider.cvs.implementation=cvs_native with Maven)

  []

  Here are the format for each of the supported methods, using colon as
  delimiter.

-------
scm:cvs<delimiter>local<delimiter>path_to_repository<delimiter>module_name
scm:cvs<delimiter>lserver<delimiter>[username@]servername[<delimiter>port]<delimiter>path_to_repository<delimiter>module_name
scm:cvs<delimiter>pserver<delimiter>[username[<delimiter>password]@]servername[<delimiter>port]<delimiter>path_to_repository<delimiter>module_name
scm:cvs<delimiter>ext<delimiter>[username@]servername[<delimiter>port]<delimiter>path_to_repository<delimiter>module_name
scm:cvs<delimiter>sspi<delimiter>[username@]host<delimiter>path<delimiter>module
-------

* Examples

-------
scm:cvs:pserver:anoncvs:@cvs.apache.org:/cvs/root:module
scm:cvs|pserver|username@localhost|C:/Program Files/cvsnt/repositories|module_name
scm:cvs:ext:username@cvs.apache.org:/cvs/root:module
scm:cvs:local:/cvs/root:module
scm:cvs:sspi:cvs.apache.org:2222:/cvs/root:module
-------

  If you use anonymous access, with an empty password, you need to add a colon (:) between the username and "@" like it's done in the first example.
  This tells the SCM provider that there is a password and that it is empty.

* How to choose the CVS provider implementation

  By default, the pure java CVS provider is used (which may not support SSPI protocol), so you don't need a cvs client installed on your machine.
  In some case, you can want to use the installed CVS client (for example, CVSNT). To do it, you can change the implementation to use by settings the
  'maven.scm.provider.cvs.implementation' system property:

-------
-Dmaven.scm.provider.cvs.implementation=cvs_native
-------

* Provider Configuration

  The provider configuration is defined in ${user.home}/.scm/cvs-settings.xml

** Compression level

  You can define the compression level in the provider configuration file (default value is 3). If compression level is equals to 0, there won't be any compression.

-------
<cvs-settings>
  <compressionLevel>5</compressionLevel>
</cvs-settings>
-------

  If you don't want compression, you can define the system property 'maven.scm.cvs.use_compression'.

-------
mvn -Dmaven.scm.cvs.use_compression=true scm:changelog
-------

** .cvsrc file

  By default, maven-scm doesn't use .cvsrc file. If you want to use it, you should allow it inprovider configuration file.

-------
<cvs-settings>
  <useCvsrc>true</useCvsrc>
</cvs-settings>
-------

** Trace CVS commands

  By default, maven-scm doesn't use '-t' global option of cvs command line to trace. If you want to use it, add the following lines in your provider configuration file :

-------
<cvs-settings>
  <traceCvsCommand>true</traceCvsCommand>
</cvs-settings>
-------

** Temporary CVS files

  If you want to store CVS temporary files in a specific directory instead of default or value define in $TMPDIR, add the following lines in your provider configuration file :

-------
<cvs-settings>
  <temporaryFilesDirectory>your_directory</temporaryFilesDirectory>
</cvs-settings>
-------

** Internal CVS variables

  If you want to add some internal CVS variables to the cvs command line, , add the following lines in your provider configuration file :

-------
<cvs-settings>
  <cvsVariables>
    <key1>value1</key1>
    <key2>value2</key2>
  </cvsVariables>
</cvs-settings>
-------
