Documentation/cvs-migration.txt

   1 Git for CVS users
   2 =================
   3 v0.99.5, Aug 2005
   4
   5 Ok, so you're a CVS user. That's ok, it's a treatable condition, and the
   6 first step to recovery is admitting you have a problem. The fact that
   7 you are reading this file means that you may be well on that path
   8 already.
   9
  10 The thing about CVS is that it absolutely sucks as a source control
  11 manager, and you'll thus be happy with almost anything else. Git,
  12 however, may be a bit 'too' different (read: "good") for your taste, and
  13 does a lot of things differently.
  14
  15 One particular suckage of CVS is very hard to work around: CVS is
  16 basically a tool for tracking 'file' history, while git is a tool for
  17 tracking 'project' history.  This sometimes causes problems if you are
  18 used to doing very strange things in CVS, in particular if you're doing
  19 things like making branches of just a subset of the project.  Git can't
  20 track that, since git never tracks things on the level of an individual
  21 file, only on the whole project level.
  22
  23 The good news is that most people don't do that, and in fact most sane
  24 people think it's a bug in CVS that makes it tag (and check in changes)
  25 one file at a time.  So most projects you'll ever see will use CVS
  26 'as if' it was sane.  In which case you'll find it very easy indeed to
  27 move over to Git.
  28
  29 First off: this is not a git tutorial. See
  30 link:tutorial.html[Documentation/tutorial.txt] for how git
  31 actually works. This is more of a random collection of gotcha's
  32 and notes on converting from CVS to git.
  33
  34 Second: CVS has the notion of a "repository" as opposed to the thing
  35 that you're actually working in (your working directory, or your
  36 "checked out tree").  Git does not have that notion at all, and all git
  37 working directories 'are' the repositories.  However, you can easily
  38 emulate the CVS model by having one special "global repository", which
  39 people can synchronize with.  See details later, but in the meantime
  40 just keep in mind that with git, every checked out working tree will
  41 have a full revision control history of its own.
  42
  43
  44 Importing a CVS archive
  45 -----------------------
  46
  47 Ok, you have an old project, and you want to at least give git a chance
  48 to see how it performs. The first thing you want to do (after you've
  49 gone through the git tutorial, and generally familiarized yourself with
  50 how to commit stuff etc in git) is to create a git'ified version of your
  51 CVS archive.
  52
  53 Happily, that's very easy indeed. Git will do it for you, although git
  54 will need the help of a program called "cvsps":
  55
  56         http://www.cobite.com/cvsps/
  57
  58 which is not actually related to git at all, but which makes CVS usage
  59 look almost sane (ie you almost certainly want to have it even if you
  60 decide to stay with CVS). However, git will want 'at least' version 2.1
  61 of cvsps (available at the address above), and in fact will currently
  62 refuse to work with anything else.
  63
  64 Once you've gotten (and installed) cvsps, you may or may not want to get
  65 any more familiar with it, but make sure it is in your path. After that,
  66 the magic command line is
  67
  68         git cvsimport -v -d <cvsroot> -C <destination> <module>
  69
  70 which will do exactly what you'd think it does: it will create a git
  71 archive of the named CVS module. The new archive will be created in the
  72 subdirectory named <destination>; it'll be created if it doesn't exist.
  73 Default is the local directory.
  74
  75 It can take some time to actually do the conversion for a large archive
  76 since it involves checking out from CVS every revision of every file,
  77 and the conversion script is reasonably chatty unless you omit the '-v'
  78 option, but on some not very scientific tests it averaged about twenty
  79 revisions per second, so a medium-sized project should not take more
  80 than a couple of minutes.  For larger projects or remote repositories,
  81 the process may take longer.
  82
  83 After the (initial) import is done, the CVS archive's current head
  84 revision will be checked out -- thus, you can start adding your own
  85 changes right away.
  86
  87 The import is incremental, i.e. if you call it again next month it'll
  88 fetch any CVS updates that have been happening in the meantime. The
  89 cut-off is date-based, so don't change the branches that were imported
  90 from CVS.
  91
  92 You can merge those updates (or, in fact, a different CVS branch) into
  93 your main branch:
  94
  95         git resolve HEAD origin "merge with current CVS HEAD"
  96
  97 The HEAD revision from CVS is named "origin", not "HEAD", because git
  98 already uses "HEAD". (If you don't like 'origin', use cvsimport's
  99 '-o' option to change it.)
 100
 101
 102 Emulating CVS behaviour
 103 -----------------------
 104
 105
 106 So, by now you are convinced you absolutely want to work with git, but
 107 at the same time you absolutely have to have a central repository.
 108 Step back and think again. Okay, you still need a single central
 109 repository? There are several ways to go about that:
 110
 111 1. Designate a person responsible to pull all branches. Make the
 112 repository of this person public, and make every team member
 113 pull regularly from it.
 114
 115 2. Set up a public repository with read/write access for every team
 116 member. Use "git pull/push" as you used "cvs update/commit".  Be
 117 sure that your repository is up to date before pushing, just
 118 like you used to do with "cvs commit"; your push will fail if
 119 what you are pushing is not up to date.
 120
 121 3. Make the repository of every team member public. It is the
 122 responsibility of each single member to pull from every other
 123 team member.
 124
 125
 126 CVS annotate
 127 ------------
 128
 129 So, something has gone wrong, and you don't know whom to blame, and
 130 you're an ex-CVS user and used to do "cvs annotate" to see who caused
 131 the breakage. You're looking for the "git annotate", and it's just
 132 claiming not to find such a script. You're annoyed.
 133
 134 Yes, that's right.  Core git doesn't do "annotate", although it's
 135 technically possible, and there are at least two specialized scripts out
 136 there that can be used to get equivalent information (see the git
 137 mailing list archives for details).
 138
 139 Git has a couple of alternatives, though, that you may find sufficient
 140 or even superior depending on your use.  One is called "git-whatchanged"
 141 (for obvious reasons) and the other one is called "pickaxe" ("a tool for
 142 the software archeologist").
 143
 144 The "git-whatchanged" script is a truly trivial script that can give you
 145 a good overview of what has changed in a file or a directory (or an
 146 arbitrary list of files or directories).  The "pickaxe" support is an
 147 additional layer that can be used to further specify exactly what you're
 148 looking for, if you already know the specific area that changed.
 149
 150 Let's step back a bit and think about the reason why you would
 151 want to do "cvs annotate a-file.c" to begin with.
 152
 153 You would use "cvs annotate" on a file when you have trouble
 154 with a function (or even a single "if" statement in a function)
 155 that happens to be defined in the file, which does not do what
 156 you want it to do.  And you would want to find out why it was
 157 written that way, because you are about to modify it to suit
 158 your needs, and at the same time you do not want to break its
 159 current callers.  For that, you are trying to find out why the
 160 original author did things that way in the original context.
 161
 162 Many times, it may be enough to see the commit log messages of
 163 commits that touch the file in question, possibly along with the
 164 patches themselves, like this:
 165
 166         $ git-whatchanged -p a-file.c
 167
 168 This will show log messages and patches for each commit that
 169 touches a-file.
 170
 171 This, however, may not be very useful when this file has many
 172 modifications that are not related to the piece of code you are
 173 interested in.  You would see many log messages and patches that
 174 do not have anything to do with the piece of code you are
 175 interested in.  As an example, assuming that you have this piece
 176 of code that you are interested in in the HEAD version:
 177
 178         if (frotz) {
 179                 nitfol();
 180         }
 181
 182 you would use git-rev-list and git-diff-tree like this:
 183
 184         $ git-rev-list HEAD |
 185           git-diff-tree --stdin -v -p -S'if (frotz) {
 186                 nitfol();
 187         }'
 188
 189 We have already talked about the "\--stdin" form of git-diff-tree
 190 command that reads the list of commits and compares each commit
 191 with its parents.  The git-whatchanged command internally runs
 192 the equivalent of the above command, and can be used like this:
 193
 194         $ git-whatchanged -p -S'if (frotz) {
 195                 nitfol();
 196         }'
 197
 198 When the -S option is used, git-diff-tree command outputs
 199 differences between two commits only if one tree has the
 200 specified string in a file and the corresponding file in the
 201 other tree does not.  The above example looks for a commit that
 202 has the "if" statement in it in a file, but its parent commit
 203 does not have it in the same shape in the corresponding file (or
 204 the other way around, where the parent has it and the commit
 205 does not), and the differences between them are shown, along
 206 with the commit message (thanks to the -v flag).  It does not
 207 show anything for commits that do not touch this "if" statement.
 208
 209 Also, in the original context, the same statement might have
 210 appeared at first in a different file and later the file was
 211 renamed to "a-file.c".  CVS annotate would not help you to go
 212 back across such a rename, but GIT would still help you in such
 213 a situation.  For that, you can give the -C flag to
 214 git-diff-tree, like this:
 215
 216         $ git-whatchanged -p -C -S'if (frotz) {
 217                 nitfol();
 218         }'
 219
 220 When the -C flag is used, file renames and copies are followed.
 221 So if the "if" statement in question happens to be in "a-file.c"
 222 in the current HEAD commit, even if the file was originally
 223 called "o-file.c" and then renamed in an earlier commit, or if
 224 the file was created by copying an existing "o-file.c" in an
 225 earlier commit, you will not lose track.  If the "if" statement
 226 did not change across such a rename or copy, then the commit that
 227 does rename or copy would not show in the output, and if the
 228 "if" statement was modified while the file was still called
 229 "o-file.c", it would find the commit that changed the statement
 230 when it was in "o-file.c".
 231
 232 NOTE: The current versions of "git-diff-tree -C" is not eager
 233   enough to find copies, and it will miss the fact that a-file.c
 234   was created by copying o-file.c unless o-file.c was somehow
 235   changed in the same commit.
 236
 237 You can use the --pickaxe-all flag in addition to the -S flag.
 238 This causes the differences from all the files contained in
 239 those two commits, not just the differences between the files
 240 that contain this changed "if" statement:
 241
 242         $ git-whatchanged -p -C -S'if (frotz) {
 243                 nitfol();
 244         }' --pickaxe-all
 245
 246 NOTE: This option is called "--pickaxe-all" because -S
 247   option is internally called "pickaxe", a tool for software
 248   archaeologists.