summaryrefslogtreecommitdiff
path: root/Documentation/howto/maintain-git.txt
blob: ca4378740c6a5cd396c9105362078d16836e1c25 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
From: Junio C Hamano <gitster@pobox.com>
Date: Wed, 21 Nov 2007 16:32:55 -0800
Subject: Addendum to "MaintNotes"
Abstract: Imagine that Git development is racing along as usual, when our friendly
 neighborhood maintainer is struck down by a wayward bus. Out of the
 hordes of suckers (loyal developers), you have been tricked (chosen) to
 step up as the new maintainer. This howto will show you "how to" do it.
Content-type: text/asciidoc
 
How to maintain Git
===================
 
Activities
----------
 
The maintainer's Git time is spent on three activities.
 
 - Communication (45%)
 
   Mailing list discussions on general design, fielding user
   questions, diagnosing bug reports; reviewing, commenting on,
   suggesting alternatives to, and rejecting patches.
 
 - Integration (50%)
 
   Applying new patches from the contributors while spotting and
   correcting minor mistakes, shuffling the integration and
   testing branches, pushing the results out, cutting the
   releases, and making announcements.
 
 - Own development (5%)
 
   Scratching my own itch and sending proposed patch series out.
 
The Policy
----------
 
The policy on Integration is informally mentioned in "A Note
from the maintainer" message, which is periodically posted to
this mailing list after each feature release is made.
 
 - Feature releases are numbered as vX.Y.0 and are meant to
   contain bugfixes and enhancements in any area, including
   functionality, performance and usability, without regression.
 
 - One release cycle for a feature release is expected to last for
   eight to ten weeks.
 
 - Maintenance releases are numbered as vX.Y.Z and are meant
   to contain only bugfixes for the corresponding vX.Y.0 feature
   release and earlier maintenance releases vX.Y.W (W < Z).
 
 - 'master' branch is used to prepare for the next feature
   release. In other words, at some point, the tip of 'master'
   branch is tagged with vX.Y.0.
 
 - 'maint' branch is used to prepare for the next maintenance
   release.  After the feature release vX.Y.0 is made, the tip
   of 'maint' branch is set to that release, and bugfixes will
   accumulate on the branch, and at some point, the tip of the
   branch is tagged with vX.Y.1, vX.Y.2, and so on.
 
 - 'next' branch is used to publish changes (both enhancements
   and fixes) that (1) have worthwhile goal, (2) are in a fairly
   good shape suitable for everyday use, (3) but have not yet
   demonstrated to be regression free.  New changes are tested
   in 'next' before merged to 'master'.
 
 - 'pu' branch is used to publish other proposed changes that do
   not yet pass the criteria set for 'next'.
 
 - The tips of 'master' and 'maint' branches will not be rewound to
   allow people to build their own customization on top of them.
   Early in a new development cycle, 'next' is rewound to the tip of
   'master' once, but otherwise it will not be rewound until the end
   of the cycle.
 
 - Usually 'master' contains all of 'maint' and 'next' contains all
   of 'master'.  'pu' contains all the topics merged to 'next', but
   is rebuilt directly on 'master'.
 
 - The tip of 'master' is meant to be more stable than any
   tagged releases, and the users are encouraged to follow it.
 
 - The 'next' branch is where new action takes place, and the
   users are encouraged to test it so that regressions and bugs
   are found before new topics are merged to 'master'.
 
Note that before v1.9.0 release, the version numbers used to be
structured slightly differently.  vX.Y.Z were feature releases while
vX.Y.Z.W were maintenance releases for vX.Y.Z.
 
 
A Typical Git Day
-----------------
 
A typical Git day for the maintainer implements the above policy
by doing the following:
 
 - Scan mailing list.  Respond with review comments, suggestions
   etc.  Kibitz.  Collect potentially usable patches from the
   mailing list.  Patches about a single topic go to one mailbox (I
   read my mail in Gnus, and type \C-o to save/append messages in
   files in mbox format).
 
 - Write his own patches to address issues raised on the list but
   nobody has stepped up solving.  Send it out just like other
   contributors do, and pick them up just like patches from other
   contributors (see above).
 
 - Review the patches in the saved mailboxes.  Edit proposed log
   message for typofixes and clarifications, and add Acks
   collected from the list.  Edit patch to incorporate "Oops,
   that should have been like this" fixes from the discussion.
 
 - Classify the collected patches and handle 'master' and
   'maint' updates:
 
   - Obviously correct fixes that pertain to the tip of 'maint'
     are directly applied to 'maint'.
 
   - Obviously correct fixes that pertain to the tip of 'master'
     are directly applied to 'master'.
 
   - Other topics are not handled in this step.
 
   This step is done with "git am".
 
     $ git checkout master    ;# or "git checkout maint"
     $ git am -sc3 mailbox
     $ make test
 
   In practice, almost no patch directly goes to 'master' or
   'maint'.
 
 - Review the last issue of "What's cooking" message, review the
   topics ready for merging (topic->master and topic->maint).  Use
   "Meta/cook -w" script (where Meta/ contains a checkout of the
   'todo' branch) to aid this step.
 
   And perform the merge.  Use "Meta/Reintegrate -e" script (see
   later) to aid this step.
 
     $ Meta/cook -w last-issue-of-whats-cooking.mbox
 
     $ git checkout master    ;# or "git checkout maint"
     $ echo ai/topic | Meta/Reintegrate -e ;# "git merge ai/topic"
     $ git log -p ORIG_HEAD.. ;# final review
     $ git diff ORIG_HEAD..   ;# final review
     $ make test              ;# final review
 
 - Handle the remaining patches:
 
   - Anything unobvious that is applicable to 'master' (in other
     words, does not depend on anything that is still in 'next'
     and not in 'master') is applied to a new topic branch that
     is forked from the tip of 'master'.  This includes both
     enhancements and unobvious fixes to 'master'.  A topic
     branch is named as ai/topic where "ai" is two-letter string
     named after author's initial and "topic" is a descriptive name
     of the topic (in other words, "what's the series is about").
 
   - An unobvious fix meant for 'maint' is applied to a new
     topic branch that is forked from the tip of 'maint'.  The
     topic is named as ai/maint-topic.
 
   - Changes that pertain to an existing topic are applied to
     the branch, but:
 
     - obviously correct ones are applied first;
 
     - questionable ones are discarded or applied to near the tip;
 
   - Replacement patches to an existing topic are accepted only
     for commits not in 'next'.
 
   The above except the "replacement" are all done with:
 
     $ git checkout ai/topic ;# or "git checkout -b ai/topic master"
     $ git am -sc3 mailbox
 
   while patch replacement is often done by:
 
     $ git format-patch ai/topic~$n..ai/topic ;# export existing
 
   then replace some parts with the new patch, and reapplying:
 
     $ git checkout ai/topic
     $ git reset --hard ai/topic~$n
     $ git am -sc3 -s 000*.txt
 
   The full test suite is always run for 'maint' and 'master'
   after patch application; for topic branches the tests are run
   as time permits.
 
 - Merge maint to master as needed:
 
     $ git checkout master
     $ git merge maint
     $ make test
 
 - Merge master to next as needed:
 
     $ git checkout next
     $ git merge master
     $ make test
 
 - Review the last issue of "What's cooking" again and see if topics
   that are ready to be merged to 'next' are still in good shape
   (e.g. has there any new issue identified on the list with the
   series?)
 
 - Prepare 'jch' branch, which is used to represent somewhere
   between 'master' and 'pu' and often is slightly ahead of 'next'.
 
     $ Meta/Reintegrate master..pu >Meta/redo-jch.sh
 
   The result is a script that lists topics to be merged in order to
   rebuild 'pu' as the input to Meta/Reintegrate script.  Remove
   later topics that should not be in 'jch' yet.  Add a line that
   consists of '### match next' before the name of the first topic
   in the output that should be in 'jch' but not in 'next' yet.
 
 - Now we are ready to start merging topics to 'next'.  For each
   branch whose tip is not merged to 'next', one of three things can
   happen:
 
   - The commits are all next-worthy; merge the topic to next;
   - The new parts are of mixed quality, but earlier ones are
     next-worthy; merge the early parts to next;
   - Nothing is next-worthy; do not do anything.
 
   This step is aided with Meta/redo-jch.sh script created earlier.
   If a topic that was already in 'next' gained a patch, the script
   would list it as "ai/topic~1".  To include the new patch to the
   updated 'next', drop the "~1" part; to keep it excluded, do not
   touch the line.  If a topic that was not in 'next' should be
   merged to 'next', add it at the end of the list.  Then:
 
     $ git checkout -B jch master
     $ Meta/redo-jch.sh -c1
 
   to rebuild the 'jch' branch from scratch.  "-c1" tells the script
   to stop merging at the first line that begins with '###'
   (i.e. the "### match next" line you added earlier).
 
   At this point, build-test the result.  It may reveal semantic
   conflicts (e.g. a topic renamed a variable, another added a new
   reference to the variable under its old name), in which case
   prepare an appropriate merge-fix first (see appendix), and
   rebuild the 'jch' branch from scratch, starting at the tip of
   'master'.
 
   Then do the same to 'next'
 
     $ git checkout next
     $ sh Meta/redo-jch.sh -c1 -e
 
   The "-e" option allows the merge message that comes from the
   history of the topic and the comments in the "What's cooking" to
   be edited.  The resulting tree should match 'jch' as the same set
   of topics are merged on 'master'; otherwise there is a mismerge.
   Investigate why and do not proceed until the mismerge is found
   and rectified.
 
     $ git diff jch next
 
   When all is well, clean up the redo-jch.sh script with
 
     $ sh Meta/redo-jch.sh -u
 
   This removes topics listed in the script that have already been
   merged to 'master'.  This may lose '### match next' marker;
   add it again to the appropriate place when it happens.
 
 - Rebuild 'pu'.
 
     $ Meta/Reintegrate master..pu >Meta/redo-pu.sh
 
   Edit the result by adding new topics that are not still in 'pu'
   in the script.  Then
 
     $ git checkout -B pu jch
     $ sh Meta/redo-pu.sh
 
   When all is well, clean up the redo-pu.sh script with
 
     $ sh Meta/redo-pu.sh -u
 
   Double check by running
 
     $ git branch --no-merged pu
 
   to see there is no unexpected leftover topics.
 
   At this point, build-test the result for semantic conflicts, and
   if there are, prepare an appropriate merge-fix first (see
   appendix), and rebuild the 'pu' branch from scratch, starting at
   the tip of 'jch'.
 
 - Update "What's cooking" message to review the updates to
   existing topics, newly added topics and graduated topics.
 
   This step is helped with Meta/cook script.
 
     $ Meta/cook
 
   This script inspects the history between master..pu, finds tips
   of topic branches, compares what it found with the current
   contents in Meta/whats-cooking.txt, and updates that file.
   Topics not listed in the file but are found in master..pu are
   added to the "New topics" section, topics listed in the file that
   are no longer found in master..pu are moved to the "Graduated to
   master" section, and topics whose commits changed their states
   (e.g. used to be only in 'pu', now merged to 'next') are updated
   with change markers "<<" and ">>".
 
   Look for lines enclosed in "<<" and ">>"; they hold contents from
   old file that are replaced by this integration round.  After
   verifying them, remove the old part.  Review the description for
   each topic and update its doneness and plan as needed.  To review
   the updated plan, run
 
     $ Meta/cook -w
 
   which will pick up comments given to the topics, such as "Will
   merge to 'next'", etc. (see Meta/cook script to learn what kind
   of phrases are supported).
 
 - Compile, test and install all four (five) integration branches;
   Meta/Dothem script may aid this step.
 
 - Format documentation if the 'master' branch was updated;
   Meta/dodoc.sh script may aid this step.
 
 - Push the integration branches out to public places; Meta/pushall
   script may aid this step.
 
Observations
------------
 
Some observations to be made.
 
 * Each topic is tested individually, and also together with other
   topics cooking first in 'pu', then in 'jch' and then in 'next'.
   Until it matures, no part of it is merged to 'master'.
 
 * A topic already in 'next' can get fixes while still in
   'next'.  Such a topic will have many merges to 'next' (in
   other words, "git log --first-parent next" will show many
   "Merge branch 'ai/topic' to next" for the same topic.
 
 * An unobvious fix for 'maint' is cooked in 'next' and then
   merged to 'master' to make extra sure it is Ok and then
   merged to 'maint'.
 
 * Even when 'next' becomes empty (in other words, all topics
   prove stable and are merged to 'master' and "git diff master
   next" shows empty), it has tons of merge commits that will
   never be in 'master'.
 
 * In principle, "git log --first-parent master..next" should
   show nothing but merges (in practice, there are fixup commits
   and reverts that are not merges).
 
 * Commits near the tip of a topic branch that are not in 'next'
   are fair game to be discarded, replaced or rewritten.
   Commits already merged to 'next' will not be.
 
 * Being in the 'next' branch is not a guarantee for a topic to
   be included in the next feature release.  Being in the
   'master' branch typically is.
 
 
Appendix
--------
 
Preparing a "merge-fix"
~~~~~~~~~~~~~~~~~~~~~~~
 
A merge of two topics may not textually conflict but still have
conflict at the semantic level. A classic example is for one topic
to rename an variable and all its uses, while another topic adds a
new use of the variable under its old name. When these two topics
are merged together, the reference to the variable newly added by
the latter topic will still use the old name in the result.
 
The Meta/Reintegrate script that is used by redo-jch and redo-pu
scripts implements a crude but usable way to work this issue around.
When the script merges branch $X, it checks if "refs/merge-fix/$X"
exists, and if so, the effect of it is squashed into the result of
the mechanical merge.  In other words,
 
     $ echo $X | Meta/Reintegrate
 
is roughly equivalent to this sequence:
 
     $ git merge --rerere-autoupdate $X
     $ git commit
     $ git cherry-pick -n refs/merge-fix/$X
     $ git commit --amend
 
The goal of this "prepare a merge-fix" step is to come up with a
commit that can be squashed into a result of mechanical merge to
correct semantic conflicts.
 
After finding that the result of merging branch "ai/topic" to an
integration branch had such a semantic conflict, say pu~4, check the
problematic merge out on a detached HEAD, edit the working tree to
fix the semantic conflict, and make a separate commit to record the
fix-up:
 
     $ git checkout pu~4
     $ git show -s --pretty=%s ;# double check
     Merge branch 'ai/topic' to pu
     $ edit
     $ git commit -m 'merge-fix/ai/topic' -a
 
Then make a reference "refs/merge-fix/ai/topic" to point at this
result:
 
     $ git update-ref refs/merge-fix/ai/topic HEAD
 
Then double check the result by asking Meta/Reintegrate to redo the
merge:
 
     $ git checkout pu~5 ;# the parent of the problem merge
     $ echo ai/topic | Meta/Reintegrate
     $ git diff pu~4
 
This time, because you prepared refs/merge-fix/ai/topic, the
resulting merge should have been tweaked to include the fix for the
semantic conflict.
 
Note that this assumes that the order in which conflicting branches
are merged does not change.  If the reason why merging ai/topic
branch needs this merge-fix is because another branch merged earlier
to the integration branch changed the underlying assumption ai/topic
branch made (e.g. ai/topic branch added a site to refer to a
variable, while the other branch renamed that variable and adjusted
existing use sites), and if you changed redo-jch (or redo-pu) script
to merge ai/topic branch before the other branch, then the above
merge-fix should not be applied while merging ai/topic, but should
instead be applied while merging the other branch.  You would need
to move the fix to apply to the other branch, perhaps like this:
 
      $ mf=refs/merge-fix
      $ git update-ref $mf/$the_other_branch $mf/ai/topic
      $ git update-ref -d $mf/ai/topic