chiark / gitweb /
7ffeaef2cc023e934f10c6bdbdf6a4b4c5e3b33c
[dgit.git] / dgit-maint-debrebase.7.pod
1 =head1 NAME
2
3 dgit - tutorial for package maintainers, using a workflow centered around git-debrebase(1)
4
5 =head1 INTRODUCTION
6
7 This document describes elements of a workflow for maintaining a
8 non-native Debian package using B<dgit>.  We maintain the Debian delta
9 as a series of git commits on our master branch.  We use
10 git-debrebase(1) to shuffle our branch such that this series of git
11 commits appears at the end of the branch.  All the public git history
12 is fast-forwarding, i.e., we do not rewrite and force-push.
13
14 Some advantages of this workflow:
15
16 =over 4
17
18 =item
19
20 Manipulate the delta queue using the full power of git-rebase(1),
21 instead of relying on quilt(1), and without having to switch back and
22 forth between patches-applied and patches-unapplied branches when
23 committing changes and trying to build, as with gbp-pq(1).
24
25 =item
26
27 If you are using 3.0 (quilt), provide your delta queue as a properly
28 separated series of quilt patches in the source package that you
29 upload to the archive (unlike with dgit-maint-merge(7)).
30
31 =item
32
33 Avoid the git tree being dirtied by the application or unapplication
34 of patches, as they are always applied.
35
36 =item
37
38 Benefit from dgit's safety catches.  In particular, ensure that your
39 upload always matches exactly your git HEAD.
40
41 =item
42
43 Provide your full git history in a standard format on B<dgit-repos>,
44 where it can benefit downstream dgit users, such as people using dgit
45 to do an NMU (see dgit-nmu-simple(7) and dgit-user(7)).
46
47 =item
48
49 Minimise the amount you need to know about 3.0 (quilt) in order to
50 maintain Debian source packages which use that format.
51
52 =back
53
54 This workflow is appropriate for packages where the Debian delta
55 contains multiple pieces which interact, or which you don't expect to
56 be able to upstream soon.  For packages with simple and/or short-lived
57 Debian deltas, use of git-debrebase(1) introduces unneeded complexity.
58 For such packages, consider the workflow described in
59 dgit-maint-merge(7).
60
61 =head1 INITIAL DEBIANISATION
62
63 This section explains how to start using this workflow with a new
64 package.  It should be skipped when converting an existing package to
65 this workflow.
66
67 =head2 When upstream tags releases in git
68
69 Suppose that the latest stable upstream release is 1.2.2, and this has
70 been tagged '1.2.2' by upstream.
71
72 =over 4
73
74     % git clone -oupstream https://some.upstream/foo.git
75     % cd foo
76     % git verify-tag 1.2.2
77     % git reset --hard 1.2.2
78     % git branch --unset-upstream
79
80 =back
81
82 The final command detaches your master branch from the upstream
83 remote, so that git doesn't try to push anything there, or merge
84 unreleased upstream commits.  To maintain a copy of your packaging
85 branch on B<salsa.debian.org> in addition to B<dgit-repos>, you can do
86 something like this:
87
88 =over 4
89
90     % git remote add -f origin salsa.debian.org:Debian/foo.git
91     % git push --follow-tags -u origin master
92
93 =back
94
95 Now go ahead and Debianise your package.  Make commits on the master
96 branch, adding things in the I<debian/> directory, or patching the
97 upstream source.  For technical reasons, B<it is essential that your
98 first commit introduces the debian/ directory containing at least one
99 file, and does nothing else.> In other words, make a commit
100 introducing I<debian/> before patching the upstream source.
101
102 Finally, you need an orig tarball:
103
104 =over 4
105
106     % git deborig
107
108 =back
109
110 See git-deborig(1) if this fails.
111
112 This tarball is ephemeral and easily regenerated, so we don't commit
113 it anywhere (e.g. with tools like pristine-tar(1)).
114
115 =head3 Comparing upstream's tarball releases
116
117 =over 4
118
119 The above assumes that you know how to build the package from git and
120 that doing so is straightforward.
121
122 If, as a user of the upstream source, you usually build from upstream
123 tarball releases, rather than upstream git tags, you will sometimes
124 find that the git tree doesn't contain everything that is in the
125 tarball.
126
127 Additional build steps may be needed.  For example, you may need your
128 I<debian/rules> to run autotools.
129
130 You can compare the upstream tarball release, and upstream git tag,
131 within git, by importing the tarball into git as described in the
132 next section, using a different value for 'upstream-tag', and then
133 using git-diff(1) to compare the imported tarball to the release tag.
134
135 =back
136
137 =head2 When upstream releases only tarballs
138
139 Because we want to work in git, we need a virtual upstream branch with
140 virtual release tags.  gbp-import-orig(1) can manage this for us.  To
141 begin
142
143 =over 4
144
145     % mkdir foo
146     % cd foo
147     % git init
148
149 =back
150
151 Now create I<debian/gbp.conf>:
152
153 =over 4
154
155     [DEFAULT]
156     upstream-branch = upstream
157     debian-branch = master
158     upstream-tag = %(version)s
159
160     sign-tags = True
161     pristine-tar = False
162     pristine-tar-commit = False
163
164     [import-orig]
165     merge-mode = merge
166
167 =back
168
169 gbp-import-orig(1) requires a pre-existing upstream branch:
170
171 =over 4
172
173     % git add debian/gbp.conf && git commit -m "create gbp.conf"
174     % git checkout --orphan upstream
175     % git rm -rf .
176     % git commit --allow-empty -m "initial, empty branch for upstream source"
177     % git checkout -f master
178
179 =back
180
181 Then we can import the upstream version:
182
183 =over 4
184
185     % gbp import-orig --merge-mode=replace ../foo_1.2.2.orig.tar.xz
186
187 =back
188
189 Our upstream branch cannot be pushed to B<dgit-repos>, but since we
190 will need it whenever we import a new upstream version, we must push
191 it somewhere.  The usual choice is B<salsa.debian.org>:
192
193 =over 4
194
195     % git remote add -f origin salsa.debian.org:Debian/foo.git
196     % git push --follow-tags -u origin master upstream
197
198 =back
199
200 You are now ready to proceed as above, making commits to the
201 I<debian/> directory and to the upstream source.  As above, for
202 technical reasons, B<it is essential that your first commit introduces
203 the debian/ directory containing at least one file, and does nothing
204 else.>  In other words, make a commit introducing I<debian/> before
205 patching the upstream source.
206
207 =head1 CONVERTING AN EXISTING PACKAGE
208
209 This section explains how to convert an existing Debian package to
210 this workflow.  It should be skipped when debianising a new package.
211
212 =head2 No existing git history
213
214 =over 4
215
216     % dgit clone foo
217     % cd foo
218     % git remote add -f upstream https://some.upstream/foo.git
219
220 =back
221
222 =head2 Existing git history using another workflow
223
224 First, if you don't already have the git history locally, clone it,
225 and obtain the corresponding orig.tar from the archive:
226
227 =over 4
228
229     % git clone salsa.debian.org:Debian/foo
230     % cd foo
231     % origtargz
232
233 =back
234
235 If your tree is patches-unapplied, some conversion work is needed.
236 You can use
237
238 =over 4
239
240     git debrebase convert-from-gbp
241
242 =back
243
244 Then make new upstream tags available:
245
246 =over 4
247
248     % git remote add -f upstream https://some.upstream/foo.git
249
250 =back
251
252 Now you simply need to ensure that your git HEAD is dgit-compatible,
253 i.e., it is exactly what you would get if you deleted .git, invoked
254 B<dpkg-buildpackage -S>, and then unpacked the resultant source
255 package.
256
257 To achieve this, you might need to delete
258 I<debian/source/local-options>.  One way to have dgit check your
259 progress is to run B<dgit build-source>.
260
261 The first dgit push will require I<--overwrite>.
262
263 =head1 GIT CONFIGURATION
264
265 git-debrebase does not yet support using B<git merge> to merge
266 divergent branches of development (see "OTHER MERGES" in
267 git-debrebase(5)).  You should configure git such that B<git pull>
268 does not try to merge:
269
270 =over 4
271
272     % git config --local pull.rebase true
273
274 =back
275
276 Now when you pull work from other Debian contributors, git will rebase
277 your work on top of theirs.
278
279 If you use this clone for upstream development in addition to
280 Debian packaging work, you may not want to set this global setting.
281 Instead, see the B<branch.autoSetupRebase> and
282 B<branch.E<lt>nameE<gt>.rebase> settings in git-config(5).
283
284 =head1 IMPORTING NEW UPSTREAM RELEASES
285
286 There are two steps: obtaining git refs that correspond to the new
287 release, and importing that release using git-debrebase(1).
288
289 =head2 Obtaining the release
290
291 =head3 When upstream tags releases in git
292
293 =over 4
294
295     % git remote update
296
297 =back
298
299 =head3 When upstream releases only tarballs
300
301 You will need the I<debian/gbp.conf> from "When upstream releases only
302 tarballs", above.  You will also need your upstream branch.  Above, we
303 pushed this to B<salsa.debian.org>.  You will need to clone or fetch
304 from there, instead of relying on B<dgit clone>/B<dgit fetch> alone.
305
306 Then, either
307
308 =over 4
309
310     % gbp import-orig --no-merge ../foo_1.2.3.orig.tar.xz
311
312 =back
313
314 or if you have a working watch file
315
316 =over 4
317
318     % gbp import-orig --no-merge --uscan
319
320 =back
321
322 =head2 Importing the release
323
324 =over 4
325
326     % git debrebase new-upstream-v0 1.2.3
327
328 =back
329
330 This invocation of git-debrebase(1) involves a git rebase.  You may
331 need to resolve conflicts if the Debian delta queue does not apply
332 cleanly to the new upstream source.
333
334 If all went well, you can now review the merge of the new upstream
335 release:
336
337 =over 4
338
339     git diff debian/1.2.2-1..HEAD -- . ':!debian'
340
341 =back
342
343 Pass I<--stat> just to see the list of changed files, which is useful
344 to determine whether there are any new or deleted files to may need
345 accounting for in your copyright file.
346
347 If you obtained a tarball from upstream, you are ready to try a build.
348 If you merged a git tag from upstream, you will first need to generate
349 a tarball:
350
351 =over 4
352
353     % git deborig
354
355 =back
356
357 =head1 EDITING THE DEBIAN PACKAGING
358
359 Just make commits on master that change the contents of I<debian/>.
360
361 =head1 EDITING THE DELTA QUEUE
362
363 =head2 Adding new patches
364
365 Adding new patches is straightforward: just make commits touching only
366 files outside of the I<debian/> directory.  You can also use tools
367 like git-revert(1), git-am(1) and git-cherry-pick(1).
368
369 =head2 Editing patches: starting a debrebase
370
371 git-debrebase(1) is a wrapper around git-rebase(1) which allows us to
372 edit, re-order and delete patches.  Run
373
374 =over 4
375
376     % git debrebase -i
377
378 =back
379
380 to start an interactive rebase.  You can edit, re-order and delete
381 commits just as you would during B<git rebase -i>.
382
383 =head2 Editing patches: finishing a debrebase
384
385 After completing the git rebase, your branch will not be a
386 fast-forward of the git HEAD you had before the rebase.  This means
387 that we cannot push the branch anywhere.  If you are ready to upload,
388 B<dgit push> or B<dgit push-source> will take care of fixing this up
389 for you.
390
391 If you are not yet ready to upload, and want to push your branch to a
392 git remote such as B<salsa.debian.org>,
393
394 =over 4
395
396     % git debrebase conclude
397
398 =back
399
400 Note that each time you conclude a debrebase you introduce a
401 pseudomerge into your git history, which may make it harder to read.
402 Try to do all of the editing of the delta queue that you think will be
403 needed for this upload in a single debrebase, so that there is a
404 single debrebase stitch.
405
406 =head1 BUILDING AND UPLOADING
407
408 You can use dpkg-buildpackage(1) for test builds.  When you are ready
409 to build for an upload, use B<dgit sbuild>.
410
411 Upload with B<dgit push> or B<dgit push-source>.  Remember to pass
412 I<--new> if the package is new in the target suite.
413
414 Right before uploading, if you did not just already do so, you might
415 want to have git-debrebase(1) shuffle your branch such that the Debian
416 delta queue appears right at the tip of the branch you will push:
417
418 =over 4
419
420     % git debrebase
421     % dgit push-source
422
423 =back
424
425 Note that this will introduce a new pseudomerge.
426
427 After dgit pushing, be sure to git push to B<salsa.debian.org>, if
428 you're using that.
429
430 =head1 HANDLING DFSG-NON-FREE MATERIAL
431
432 This covers only DFSG-non-free material.  Material which is legally
433 dangerous (for example, files which are actually illegal) cannot be
434 handled this way.
435
436 If you encounter possibly-legally-dangerous material in the upstream
437 source code you should seek advice.  It is often best not to make a
438 fuss on a public mailing list (at least, not at first).  Instead,
439 email your archive administrators.  For Debian that is
440  To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org
441
442 =head2 When upstream tags releases in git
443
444 We create a DFSG-clean tag to import to master:
445
446 =over 4
447
448     % git checkout -b pre-dfsg 1.2.3
449     % git rm evil.bin
450     % git commit -m "upstream version 1.2.3 DFSG-cleaned"
451     % git tag -s 1.2.3+dfsg
452     % git checkout master
453     % git branch -D pre-dfsg
454
455 =back
456
457 =head2 When upstream releases only tarballs
458
459 The easiest way to handle this is to add a B<Files-Excluded> field to
460 I<debian/copyright>, and a B<uversionmangle> setting in
461 I<debian/watch>.  See uscan(1).  Alternatively, see the I<--filter>
462 option detailed in gbp-import-orig(1).
463
464 =head1 INCORPORATING NMUS
465
466 In the simplest case,
467
468 =over 4
469
470     % dgit fetch
471     % git merge --ff-only dgit/dgit/sid
472
473 =back
474
475 If that fails, because your branch and the NMUers work represent
476 divergent branches of development, you have a number of options.  Here
477 we describe the two simplest.
478
479 =head2 Rebasing your work onto the NMU
480
481 =over 4
482
483     % git rebase dgit/dgit/sid
484
485 =back
486
487 If the NMUer added new commits modifying the upstream source, you will
488 probably want to debrebase before your next upload to tidy those up.
489
490 For example, the NMUer might have used git-revert(1) to unapply one of
491 your patches.  A debrebase will strip both the patch and the reversion
492 from the delta queue.
493
494 =head2 Manually applying the debdiff
495
496 If you cannot rebase because you have already pushed to
497 B<salsa.debian.org>, say, you can manually apply the NMU debdiff,
498 commit and debrebase.  The next B<dgit push> will require
499 I<--overwrite>.
500
501 =head1 HINTS AND TIPS
502
503 =head2 Minimising pseudomerges
504
505 Above we noted that each time you conclude a debrebase, you introduce
506 a pseudomerge into your git history, which may make it harder to read.
507
508 A convention you can use to minimise the number of pseudomerges is to
509 debrebase only right before you upload.
510
511 Before that point, instead of editing the existing delta queue, you
512 append fixup commits (and reversions of commits) that alter the
513 upstream source to the required state.  You can freely push and pull
514 from B<salsa.debian.org> during this.  Just before uploading, you
515 debrebase, once, to tidy everything up.
516
517 =head2 Upstream branches
518
519 Except in the case where upstream releases only tarballs, we do not
520 maintain a separate 'upstream' branch (unless you also happen to be
521 involved in upstream development).  We work with upstream tags rather
522 than any branches, except temporary branches used to prepare patches
523 for forwarding upstream, for example.
524
525 The thought behind this is that branches are things to which one
526 expects to commit, while tags are immutable points in history.  From
527 the Debian point of the view, the upstream source is immutable.  It's
528 our packaging to which we expect to commit.
529
530 =head2 The first ever dgit push
531
532 If this is the first ever dgit push of the package, consider passing
533 I<--deliberately-not-fast-forward> instead of I<--overwrite>.  This
534 avoids introducing a new origin commit into your git history.  (This
535 origin commit would represent the most recent non-dgit upload of the
536 package, but this should already be represented in your git history.)
537
538 =head2 Alternative ways to start a debrebase
539
540 Above we started an interactive debrebase by invoking git-debrebase(1)
541 like this:
542
543 =over 4
544
545     % git debrebase -i
546
547 =back
548
549 It is also possible to perform a non-interactive rebase, like this:
550
551 =over 4
552
553     % git debrebase -- [git-rebase options...]
554
555 =back
556
557
558 A third alternative is to have git-debrebase(1) shuffle all the Debian
559 changes to the end of your branch, and then manipulate them yourself
560 using git-rebase(1) directly.  For example,
561
562 =over 4
563
564     % git debrebase launder
565     % git rebase -i HEAD~5      # there are 4 Debian patches
566
567 =back
568
569 If you take this approach, you should be very careful not to start the
570 rebase too early.
571
572 =head1 SEE ALSO
573
574 dgit(1), dgit(7)
575
576 =head1 AUTHOR
577
578 This tutorial was written and is maintained by Sean Whitton
579 <spwhitton@spwhitton.name>.  It contains contributions from other dgit
580 contributors too - see the dgit copyright file.