| git-cvsserver(1) |
| ================ |
| |
| NAME |
| ---- |
| git-cvsserver - A CVS server emulator for Git |
| |
| SYNOPSIS |
| -------- |
| |
| SSH: |
| |
| [verse] |
| export CVS_SERVER="git cvsserver" |
| 'cvs' -d :ext:user@server/path/repo.git co <HEAD_name> |
| |
| pserver (/etc/inetd.conf): |
| |
| [verse] |
| cvspserver stream tcp nowait nobody /usr/bin/git-cvsserver git-cvsserver pserver |
| |
| Usage: |
| |
| [verse] |
| 'git-cvsserver' [<options>] [pserver|server] [<directory> ...] |
| |
| OPTIONS |
| ------- |
| |
| All these options obviously only make sense if enforced by the server side. |
| They have been implemented to resemble the linkgit:git-daemon[1] options as |
| closely as possible. |
| |
| --base-path <path>:: |
| Prepend 'path' to requested CVSROOT |
| |
| --strict-paths:: |
| Don't allow recursing into subdirectories |
| |
| --export-all:: |
| Don't check for `gitcvs.enabled` in config. You also have to specify a list |
| of allowed directories (see below) if you want to use this option. |
| |
| -V:: |
| --version:: |
| Print version information and exit |
| |
| -h:: |
| -H:: |
| --help:: |
| Print usage information and exit |
| |
| <directory>:: |
| You can specify a list of allowed directories. If no directories |
| are given, all are allowed. This is an additional restriction, gitcvs |
| access still needs to be enabled by the `gitcvs.enabled` config option |
| unless `--export-all` was given, too. |
| |
| |
| DESCRIPTION |
| ----------- |
| |
| This application is a CVS emulation layer for Git. |
| |
| It is highly functional. However, not all methods are implemented, |
| and for those methods that are implemented, |
| not all switches are implemented. |
| |
| Testing has been done using both the CLI CVS client, and the Eclipse CVS |
| plugin. Most functionality works fine with both of these clients. |
| |
| LIMITATIONS |
| ----------- |
| |
| CVS clients cannot tag, branch or perform Git merges. |
| |
| 'git-cvsserver' maps Git branches to CVS modules. This is very different |
| from what most CVS users would expect since in CVS modules usually represent |
| one or more directories. |
| |
| INSTALLATION |
| ------------ |
| |
| 1. If you are going to offer CVS access via pserver, add a line in |
| /etc/inetd.conf like |
| + |
| -- |
| ------ |
| cvspserver stream tcp nowait nobody git-cvsserver pserver |
| |
| ------ |
| Note: Some inetd servers let you specify the name of the executable |
| independently of the value of argv[0] (i.e. the name the program assumes |
| it was executed with). In this case the correct line in /etc/inetd.conf |
| looks like |
| |
| ------ |
| cvspserver stream tcp nowait nobody /usr/bin/git-cvsserver git-cvsserver pserver |
| |
| ------ |
| |
| Only anonymous access is provided by pserve by default. To commit you |
| will have to create pserver accounts, simply add a gitcvs.authdb |
| setting in the config file of the repositories you want the cvsserver |
| to allow writes to, for example: |
| |
| ------ |
| |
| [gitcvs] |
| authdb = /etc/cvsserver/passwd |
| |
| ------ |
| The format of these files is username followed by the encrypted password, |
| for example: |
| |
| ------ |
| myuser:$1Oyx5r9mdGZ2 |
| myuser:$1$BA)@$vbnMJMDym7tA32AamXrm./ |
| ------ |
| You can use the 'htpasswd' facility that comes with Apache to make these |
| files, but Apache's MD5 crypt method differs from the one used by most C |
| library's crypt() function, so don't use the -m option. |
| |
| Alternatively you can produce the password with perl's crypt() operator: |
| ----- |
| perl -e 'my ($user, $pass) = @ARGV; printf "%s:%s\n", $user, crypt($user, $pass)' $USER password |
| ----- |
| |
| Then provide your password via the pserver method, for example: |
| ------ |
| cvs -d:pserver:someuser:somepassword <at> server/path/repo.git co <HEAD_name> |
| ------ |
| No special setup is needed for SSH access, other than having Git tools |
| in the PATH. If you have clients that do not accept the CVS_SERVER |
| environment variable, you can rename 'git-cvsserver' to `cvs`. |
| |
| Note: Newer CVS versions (>= 1.12.11) also support specifying |
| CVS_SERVER directly in CVSROOT like |
| |
| ------ |
| cvs -d ":ext;CVS_SERVER=git cvsserver:user@server/path/repo.git" co <HEAD_name> |
| ------ |
| This has the advantage that it will be saved in your 'CVS/Root' files and |
| you don't need to worry about always setting the correct environment |
| variable. SSH users restricted to 'git-shell' don't need to override the default |
| with CVS_SERVER (and shouldn't) as 'git-shell' understands `cvs` to mean |
| 'git-cvsserver' and pretends that the other end runs the real 'cvs' better. |
| -- |
| 2. For each repo that you want accessible from CVS you need to edit config in |
| the repo and add the following section. |
| + |
| -- |
| ------ |
| [gitcvs] |
| enabled=1 |
| # optional for debugging |
| logFile=/path/to/logfile |
| |
| ------ |
| Note: you need to ensure each user that is going to invoke 'git-cvsserver' has |
| write access to the log file and to the database (see |
| <<dbbackend,Database Backend>>. If you want to offer write access over |
| SSH, the users of course also need write access to the Git repository itself. |
| |
| You also need to ensure that each repository is "bare" (without a Git index |
| file) for `cvs commit` to work. See linkgit:gitcvs-migration[7]. |
| |
| [[configaccessmethod]] |
| All configuration variables can also be overridden for a specific method of |
| access. Valid method names are "ext" (for SSH access) and "pserver". The |
| following example configuration would disable pserver access while still |
| allowing access over SSH. |
| ------ |
| [gitcvs] |
| enabled=0 |
| |
| [gitcvs "ext"] |
| enabled=1 |
| ------ |
| -- |
| 3. If you didn't specify the CVSROOT/CVS_SERVER directly in the checkout command, |
| automatically saving it in your 'CVS/Root' files, then you need to set them |
| explicitly in your environment. CVSROOT should be set as per normal, but the |
| directory should point at the appropriate Git repo. As above, for SSH clients |
| _not_ restricted to 'git-shell', CVS_SERVER should be set to 'git-cvsserver'. |
| + |
| -- |
| ------ |
| export CVSROOT=:ext:user@server:/var/git/project.git |
| export CVS_SERVER="git cvsserver" |
| ------ |
| -- |
| 4. For SSH clients that will make commits, make sure their server-side |
| .ssh/environment files (or .bashrc, etc., according to their specific shell) |
| export appropriate values for GIT_AUTHOR_NAME, GIT_AUTHOR_EMAIL, |
| GIT_COMMITTER_NAME, and GIT_COMMITTER_EMAIL. For SSH clients whose login |
| shell is bash, .bashrc may be a reasonable alternative. |
| |
| 5. Clients should now be able to check out the project. Use the CVS 'module' |
| name to indicate what Git 'head' you want to check out. This also sets the |
| name of your newly checked-out directory, unless you tell it otherwise with |
| `-d <dir_name>`. For example, this checks out 'master' branch to the |
| `project-master` directory: |
| + |
| ------ |
| cvs co -d project-master master |
| ------ |
| |
| [[dbbackend]] |
| DATABASE BACKEND |
| ---------------- |
| |
| 'git-cvsserver' uses one database per Git head (i.e. CVS module) to |
| store information about the repository to maintain consistent |
| CVS revision numbers. The database needs to be |
| updated (i.e. written to) after every commit. |
| |
| If the commit is done directly by using `git` (as opposed to |
| using 'git-cvsserver') the update will need to happen on the |
| next repository access by 'git-cvsserver', independent of |
| access method and requested operation. |
| |
| That means that even if you offer only read access (e.g. by using |
| the pserver method), 'git-cvsserver' should have write access to |
| the database to work reliably (otherwise you need to make sure |
| that the database is up to date any time 'git-cvsserver' is executed). |
| |
| By default it uses SQLite databases in the Git directory, named |
| `gitcvs.<module_name>.sqlite`. Note that the SQLite backend creates |
| temporary files in the same directory as the database file on |
| write so it might not be enough to grant the users using |
| 'git-cvsserver' write access to the database file without granting |
| them write access to the directory, too. |
| |
| The database cannot be reliably regenerated in a |
| consistent form after the branch it is tracking has changed. |
| Example: For merged branches, 'git-cvsserver' only tracks |
| one branch of development, and after a 'git merge' an |
| incrementally updated database may track a different branch |
| than a database regenerated from scratch, causing inconsistent |
| CVS revision numbers. `git-cvsserver` has no way of knowing which |
| branch it would have picked if it had been run incrementally |
| pre-merge. So if you have to fully or partially (from old |
| backup) regenerate the database, you should be suspicious |
| of pre-existing CVS sandboxes. |
| |
| You can configure the database backend with the following |
| configuration variables: |
| |
| Configuring database backend |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| 'git-cvsserver' uses the Perl DBI module. Please also read |
| its documentation if changing these variables, especially |
| about `DBI->connect()`. |
| |
| gitcvs.dbName:: |
| Database name. The exact meaning depends on the |
| selected database driver, for SQLite this is a filename. |
| Supports variable substitution (see below). May |
| not contain semicolons (`;`). |
| Default: '%Ggitcvs.%m.sqlite' |
| |
| gitcvs.dbDriver:: |
| Used DBI driver. You can specify any available driver |
| for this here, but it might not work. cvsserver is tested |
| with 'DBD::SQLite', reported to work with |
| 'DBD::Pg', and reported *not* to work with 'DBD::mysql'. |
| Please regard this as an experimental feature. May not |
| contain colons (`:`). |
| Default: 'SQLite' |
| |
| gitcvs.dbuser:: |
| Database user. Only useful if setting `dbDriver`, since |
| SQLite has no concept of database users. Supports variable |
| substitution (see below). |
| |
| gitcvs.dbPass:: |
| Database password. Only useful if setting `dbDriver`, since |
| SQLite has no concept of database passwords. |
| |
| gitcvs.dbTableNamePrefix:: |
| Database table name prefix. Supports variable substitution |
| (see below). Any non-alphabetic characters will be replaced |
| with underscores. |
| |
| All variables can also be set per access method, see <<configaccessmethod,above>>. |
| |
| Variable substitution |
| ^^^^^^^^^^^^^^^^^^^^^ |
| In `dbDriver` and `dbUser` you can use the following variables: |
| |
| %G:: |
| Git directory name |
| %g:: |
| Git directory name, where all characters except for |
| alphanumeric ones, `.`, and `-` are replaced with |
| `_` (this should make it easier to use the directory |
| name in a filename if wanted) |
| %m:: |
| CVS module/Git head name |
| %a:: |
| access method (one of "ext" or "pserver") |
| %u:: |
| Name of the user running 'git-cvsserver'. |
| If no name can be determined, the |
| numeric uid is used. |
| |
| ENVIRONMENT |
| ----------- |
| |
| These variables obviate the need for command-line options in some |
| circumstances, allowing easier restricted usage through git-shell. |
| |
| GIT_CVSSERVER_BASE_PATH takes the place of the argument to --base-path. |
| |
| GIT_CVSSERVER_ROOT specifies a single-directory whitelist. The |
| repository must still be configured to allow access through |
| git-cvsserver, as described above. |
| |
| When these environment variables are set, the corresponding |
| command-line arguments may not be used. |
| |
| ECLIPSE CVS CLIENT NOTES |
| ------------------------ |
| |
| To get a checkout with the Eclipse CVS client: |
| |
| 1. Select "Create a new project -> From CVS checkout" |
| 2. Create a new location. See the notes below for details on how to choose the |
| right protocol. |
| 3. Browse the 'modules' available. It will give you a list of the heads in |
| the repository. You will not be able to browse the tree from there. Only |
| the heads. |
| 4. Pick `HEAD` when it asks what branch/tag to check out. Untick the |
| "launch commit wizard" to avoid committing the .project file. |
| |
| Protocol notes: If you are using anonymous access via pserver, just select that. |
| Those using SSH access should choose the 'ext' protocol, and configure 'ext' |
| access on the Preferences->Team->CVS->ExtConnection pane. Set CVS_SERVER to |
| "`git cvsserver`". Note that password support is not good when using 'ext', |
| you will definitely want to have SSH keys setup. |
| |
| Alternatively, you can just use the non-standard extssh protocol that Eclipse |
| offer. In that case CVS_SERVER is ignored, and you will have to replace |
| the cvs utility on the server with 'git-cvsserver' or manipulate your `.bashrc` |
| so that calling 'cvs' effectively calls 'git-cvsserver'. |
| |
| CLIENTS KNOWN TO WORK |
| --------------------- |
| |
| - CVS 1.12.9 on Debian |
| - CVS 1.11.17 on MacOSX (from Fink package) |
| - Eclipse 3.0, 3.1.2 on MacOSX (see Eclipse CVS Client Notes) |
| - TortoiseCVS |
| |
| OPERATIONS SUPPORTED |
| -------------------- |
| |
| All the operations required for normal use are supported, including |
| checkout, diff, status, update, log, add, remove, commit. |
| |
| Most CVS command arguments that read CVS tags or revision numbers |
| (typically -r) work, and also support any git refspec |
| (tag, branch, commit ID, etc). |
| However, CVS revision numbers for non-default branches are not well |
| emulated, and cvs log does not show tags or branches at |
| all. (Non-main-branch CVS revision numbers superficially resemble CVS |
| revision numbers, but they actually encode a git commit ID directly, |
| rather than represent the number of revisions since the branch point.) |
| |
| Note that there are two ways to checkout a particular branch. |
| As described elsewhere on this page, the "module" parameter |
| of cvs checkout is interpreted as a branch name, and it becomes |
| the main branch. It remains the main branch for a given sandbox |
| even if you temporarily make another branch sticky with |
| cvs update -r. Alternatively, the -r argument can indicate |
| some other branch to actually checkout, even though the module |
| is still the "main" branch. Tradeoffs (as currently |
| implemented): Each new "module" creates a new database on disk with |
| a history for the given module, and after the database is created, |
| operations against that main branch are fast. Or alternatively, |
| -r doesn't take any extra disk space, but may be significantly slower for |
| many operations, like cvs update. |
| |
| If you want to refer to a git refspec that has characters that are |
| not allowed by CVS, you have two options. First, it may just work |
| to supply the git refspec directly to the appropriate CVS -r argument; |
| some CVS clients don't seem to do much sanity checking of the argument. |
| Second, if that fails, you can use a special character escape mechanism |
| that only uses characters that are valid in CVS tags. A sequence |
| of 4 or 5 characters of the form (underscore (`"_"`), dash (`"-"`), |
| one or two characters, and dash (`"-"`)) can encode various characters based |
| on the one or two letters: `"s"` for slash (`"/"`), `"p"` for |
| period (`"."`), `"u"` for underscore (`"_"`), or two hexadecimal digits |
| for any byte value at all (typically an ASCII number, or perhaps a part |
| of a UTF-8 encoded character). |
| |
| Legacy monitoring operations are not supported (edit, watch and related). |
| Exports and tagging (tags and branches) are not supported at this stage. |
| |
| CRLF Line Ending Conversions |
| ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
| |
| By default the server leaves the `-k` mode blank for all files, |
| which causes the CVS client to treat them as a text files, subject |
| to end-of-line conversion on some platforms. |
| |
| You can make the server use the end-of-line conversion attributes to |
| set the `-k` modes for files by setting the `gitcvs.usecrlfattr` |
| config variable. See linkgit:gitattributes[5] for more information |
| about end-of-line conversion. |
| |
| Alternatively, if `gitcvs.usecrlfattr` config is not enabled |
| or the attributes do not allow automatic detection for a filename, then |
| the server uses the `gitcvs.allBinary` config for the default setting. |
| If `gitcvs.allBinary` is set, then file not otherwise |
| specified will default to '-kb' mode. Otherwise the `-k` mode |
| is left blank. But if `gitcvs.allBinary` is set to "guess", then |
| the correct `-k` mode will be guessed based on the contents of |
| the file. |
| |
| For best consistency with 'cvs', it is probably best to override the |
| defaults by setting `gitcvs.usecrlfattr` to true, |
| and `gitcvs.allBinary` to "guess". |
| |
| DEPENDENCIES |
| ------------ |
| 'git-cvsserver' depends on DBD::SQLite. |
| |
| GIT |
| --- |
| Part of the linkgit:git[1] suite |