chiark / gitweb /
po/list-documents: Set translation threshold to 10%
[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 If you have an existing git history that you have pushed to an
213 ordinary git server like B<salsa.debian.org>, we start with that.  If
214 you don't already have it locally, you'll need to clone it, and obtain
215 the corresponding orig.tar from the archive:
216
217 =over 4
218
219     % git clone salsa.debian.org:Debian/foo
220     % cd foo
221     % dgit setup-new-tree
222     % origtargz
223
224 =back
225
226 If you don't have any existing git history, or you have history only
227 on the special B<dgit-repos> server, we start with B<dgit clone>:
228
229 =over 4
230
231     % dgit clone foo
232     % cd foo
233
234 =back
235
236 Then we make new upstream tags available:
237
238 =over 4
239
240     % git remote add -f upstream https://some.upstream/foo.git
241
242 =back
243
244 We now use a B<git debrebase convert-from-*> command to convert your
245 existing history to the git-debrebase(5) data model.  Which command
246 you should use depends on some facts about your repository:
247
248 =over 4
249
250 =item (A) There is no delta queue.
251
252 If there do not exist any Debian patches, use
253
254 =over 4
255
256     % git debrebase convert-from-gbp
257
258 =back
259
260 =item (B) There is a delta queue, and patches are unapplied.
261
262 This is the standard git-buildpackage(1) workflow: there are Debian
263 patches, but the upstream source is committed to git without those
264 patches applied.  Use
265
266 =over 4
267
268     % git debrebase convert-from-gbp
269
270 =back
271
272 =item (C) There is a delta queue, and patches are applied.
273
274 Use
275
276 =over 4
277
278     % git debrebase convert-from-dgit-view
279
280 =back
281
282 =back
283
284 Finally, you need to ensure that your git HEAD is dgit-compatible,
285 i.e., it is exactly what you would get if you deleted .git, invoked
286 B<dpkg-buildpackage -S>, and then unpacked the resultant source
287 package.
288
289 To achieve this, you might need to delete
290 I<debian/source/local-options>.  One way to have dgit check your
291 progress is to run B<dgit build-source>.
292
293 =head1 GIT CONFIGURATION
294
295 git-debrebase(1) does not yet support using B<git merge> to merge
296 divergent branches of development (see "OTHER MERGES" in
297 git-debrebase(5)).  You should configure git such that B<git pull>
298 does not try to merge:
299
300 =over 4
301
302     % git config --local pull.rebase true
303
304 =back
305
306 Now when you pull work from other Debian contributors, git will rebase
307 your work on top of theirs.
308
309 If you use this clone for upstream development in addition to
310 Debian packaging work, you may not want to set this global setting.
311 Instead, see the B<branch.autoSetupRebase> and
312 B<branch.E<lt>nameE<gt>.rebase> settings in git-config(5).
313
314 =head1 IMPORTING NEW UPSTREAM RELEASES
315
316 There are two steps: obtaining git refs that correspond to the new
317 release, and importing that release using git-debrebase(1).
318
319 =head2 Obtaining the release
320
321 =head3 When upstream tags releases in git
322
323 =over 4
324
325     % git remote update
326
327 =back
328
329 =head3 When upstream releases only tarballs
330
331 You will need the I<debian/gbp.conf> from "When upstream releases only
332 tarballs", above.  You will also need your upstream branch.  Above, we
333 pushed this to B<salsa.debian.org>.  You will need to clone or fetch
334 from there, instead of relying on B<dgit clone>/B<dgit fetch> alone.
335
336 Then, either
337
338 =over 4
339
340     % gbp import-orig --no-merge ../foo_1.2.3.orig.tar.xz
341
342 =back
343
344 or if you have a working watch file
345
346 =over 4
347
348     % gbp import-orig --no-merge --uscan
349
350 =back
351
352 =head2 Importing the release
353
354 =over 4
355
356     % git debrebase new-upstream 1.2.3
357
358 =back
359
360 This invocation of git-debrebase(1) involves a git rebase.  You may
361 need to resolve conflicts if the Debian delta queue does not apply
362 cleanly to the new upstream source.
363
364 If all went well, you can now review the merge of the new upstream
365 release:
366
367 =over 4
368
369     git diff debian/1.2.2-1..HEAD -- . ':!debian'
370
371 =back
372
373 Pass I<--stat> just to see the list of changed files, which is useful
374 to determine whether there are any new or deleted files to may need
375 accounting for in your copyright file.
376
377 If you obtained a tarball from upstream, you are ready to try a build.
378 If you merged a git tag from upstream, you will first need to generate
379 a tarball:
380
381 =over 4
382
383     % git deborig
384
385 =back
386
387 =head1 EDITING THE DEBIAN PACKAGING
388
389 Just make commits on master that change the contents of I<debian/>.
390
391 =head1 EDITING THE DELTA QUEUE
392
393 =head2 Adding new patches
394
395 Adding new patches is straightforward: just make commits touching only
396 files outside of the I<debian/> directory.  You can also use tools
397 like git-revert(1), git-am(1) and git-cherry-pick(1).
398
399 =head2 Editing patches: starting a debrebase
400
401 git-debrebase(1) is a wrapper around git-rebase(1) which allows us to
402 edit, re-order and delete patches.  Run
403
404 =over 4
405
406     % git debrebase -i
407
408 =back
409
410 to start an interactive rebase.  You can edit, re-order and delete
411 commits just as you would during B<git rebase -i>.
412
413 =head2 Editing patches: finishing a debrebase
414
415 After completing the git rebase, your branch will not be a
416 fast-forward of the git HEAD you had before the rebase.  This means
417 that we cannot push the branch anywhere.  If you are ready to upload,
418 B<dgit push> or B<dgit push-source> will take care of fixing this up
419 for you.
420
421 If you are not yet ready to upload, and want to push your branch to a
422 git remote such as B<salsa.debian.org>,
423
424 =over 4
425
426     % git debrebase conclude
427
428 =back
429
430 Note that each time you conclude a debrebase you introduce a
431 pseudomerge into your git history, which may make it harder to read.
432 Try to do all of the editing of the delta queue that you think will be
433 needed for this editing session in a single debrebase, so that there
434 is a single debrebase stitch.
435
436 =head1 BUILDING AND UPLOADING
437
438 You can use dpkg-buildpackage(1) for test builds.  When you are ready
439 to build for an upload, use B<dgit sbuild>, B<dgit pbuilder> or B<dgit
440 cowbuilder>.
441
442 Upload with B<dgit push> or B<dgit push-source>.  Remember to pass
443 I<--new> if the package is new in the target suite.
444
445 Right before uploading, if you did not just already do so, you might
446 want to have git-debrebase(1) shuffle your branch such that the Debian
447 delta queue appears right at the tip of the branch you will push:
448
449 =over 4
450
451     % git debrebase
452     % dgit push-source
453
454 =back
455
456 Note that this will introduce a new pseudomerge.
457
458 After dgit pushing, be sure to git push to B<salsa.debian.org>, if
459 you're using that.
460
461 =head1 HANDLING DFSG-NON-FREE MATERIAL
462
463 =head2 Illegal material
464
465 Here we explain how to handle material that is merely DFSG-non-free.
466 Material which is legally dangerous (for example, files which are
467 actually illegal) cannot be handled this way.
468
469 If you encounter possibly-legally-dangerous material in the upstream
470 source code you should seek advice.  It is often best not to make a
471 fuss on a public mailing list (at least, not at first).  Instead,
472 email your archive administrators.  For Debian that is
473  To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org
474
475 =head2 DFSG-non-free: When upstream tags releases in git
476
477 Our approach is to maintain a DFSG-clean upstream branch, and create
478 tags on this branch for each release that we want to import.  We then
479 import those tags per "Importing the release", above.
480
481 For the first upstream release that requires DFSG filtering:
482
483 =over 4
484
485     % git checkout -b upstream-dfsg 1.2.3
486     % git rm evil.bin
487     % git commit -m "upstream version 1.2.3 DFSG-cleaned"
488     % git tag -s 1.2.3+dfsg
489     % git checkout master
490     % # proceed with "Importing the release" on 1.2.3+dfsg tag
491
492 =back
493
494 And for subsequent releases (whether or not they require filtering):
495
496 =over 4
497
498     % git checkout upstream-dfsg
499     % git merge 1.2.4
500     % git rm further-evil.bin # if needed
501     % git commit -m "upstream version 1.2.4 DFSG-cleaned" # if needed
502     % git tag -s 1.2.4+dfsg
503     % git checkout master
504     % # proceed with "Importing the release" on 1.2.4+dfsg tag
505
506 =back
507
508 Our upstream-dfsg branch cannot be pushed to B<dgit-repos>, but since
509 we will need it whenever we import a new upstream version, we must
510 push it somewhere.  Assuming that you have already set up an origin
511 remote per the above,
512
513 =over 4
514
515     % git push --follow-tags -u origin master upstream-dfsg
516
517 =back
518
519 =head2 DFSG-non-free: When upstream releases only tarballs
520
521 The easiest way to handle this is to add a B<Files-Excluded> field to
522 I<debian/copyright>, and a B<uversionmangle> setting in
523 I<debian/watch>.  See uscan(1).  Alternatively, see the I<--filter>
524 option detailed in gbp-import-orig(1).
525
526 =head1 INCORPORATING NMUS
527
528 In the simplest case,
529
530 =over 4
531
532     % dgit fetch
533     % git merge --ff-only dgit/dgit/sid
534
535 =back
536
537 If that fails, because your branch and the NMUers work represent
538 divergent branches of development, you have a number of options.  Here
539 we describe the two simplest.
540
541 Note that you should not try to resolve the divergent branches by
542 editing files in I<debian/patches>.  Changes there would either cause
543 trouble, or be overwritten by git-debrebase(1).
544
545 =head2 Rebasing your work onto the NMU
546
547 =over 4
548
549     % git rebase dgit/dgit/sid
550
551 =back
552
553 If the NMUer added new commits modifying the upstream source, you will
554 probably want to debrebase before your next upload to tidy those up.
555
556 For example, the NMUer might have used git-revert(1) to unapply one of
557 your patches.  A debrebase can be used to strip both the patch and the
558 reversion from the delta queue.
559
560 =head2 Manually applying the debdiff
561
562 If you cannot rebase because you have already pushed to
563 B<salsa.debian.org>, say, you can manually apply the NMU debdiff,
564 commit and debrebase.  The next B<dgit push> will require
565 I<--overwrite>.
566
567 =head1 HINTS AND TIPS
568
569 =head2 Minimising pseudomerges
570
571 Above we noted that each time you conclude a debrebase, you introduce
572 a pseudomerge into your git history, which may make it harder to read.
573
574 A simple convention you can use to minimise the number of pseudomerges
575 is to B<git debrebase conclude> only right before you upload or push
576 to B<salsa.debian.org>.
577
578 It is possible, though much less convenient, to reduce the number of
579 pseudomerges yet further.  We debrebase only (i) when importing a new
580 release, and (ii) right before uploading.  Instead of editing the
581 existing delta queue, you append fixup commits (and reversions of
582 commits) that alter the upstream source to the required state.  You
583 can push and pull to and from B<salsa.debian.org> during this.  Just
584 before uploading, you debrebase, once, to tidy everything up.
585
586 =head2 The debian/patches directory
587
588 In this workflow, I<debian/patches> is purely an output of
589 git-debrebase(1).  You should not make changes there.  They will
590 either cause trouble, or be ignored and overwritten by
591 git-debrebase(1).
592
593 I<debian/patches> will often be out-of-date because git-debrebase(1)
594 will only regenerate it when it needs to.  So you should not rely on
595 the information in that directory.  When preparing patches to forward
596 upstream, you should use git-format-patch(1) on git commits, rather
597 than sending files from I<debian/patches>.
598
599 =head2 Upstream branches
600
601 In this workflow, we specify upstream tags rather than any branches.
602
603 Except when (i) upstream releases only tarballs, (ii) we require DFSG
604 filtering, or (iii) you also happen to be involved in upstream
605 development, we do not maintain any local branch corresponding to
606 upstream, except temporary branches used to prepare patches for
607 forwarding, and the like.
608
609 The idea here is that from Debian's point of view, upstream releases
610 are immutable points in history.  We want to make sure that we are
611 basing our Debian package on a properly identified upstream version,
612 rather than some arbitrary commit on some branch.  Tags are more
613 useful for this.
614
615 Upstream's branches remain available as the git remote tracking
616 branches for your upstream remote, e.g. I<remotes/upstream/master>.
617
618 =head2 The first ever dgit push
619
620 If this is the first ever dgit push of the package, consider passing
621 I<--deliberately-not-fast-forward> instead of I<--overwrite>.  This
622 avoids introducing a new origin commit into your git history.  (This
623 origin commit would represent the most recent non-dgit upload of the
624 package, but this should already be represented in your git history.)
625
626 =head2 Inspecting the history
627
628 The git history made by git-debrebase can seem complicated.
629 Here are some suggestions for helpful invocations of gitk and git.
630 They can be adapted for other tools like tig(1), git-log(1), magit, etc.
631
632 History of package in Debian, disregarding history from upstream:
633
634 =over
635
636     % gitk --first-parent
637
638 In a laundered branch, the delta queue is at the top.
639
640 =back
641
642 History of the packaging, excluding the delta queue:
643
644     % gitk :/debian :!/debian/patches
645
646 Just the delta queue (i.e. Debian's changes to upstream):
647
648     % gitk --first-parent -- :/ :!/debian
649
650 Full history including old versions of the delta queue:
651
652 =over
653
654     % gitk --date-order
655
656 The "Declare fast forward" commits you see have an older history
657 (usually, an older delta queue) as one parent,
658 and a newer history as the other.
659 --date-order makes gitk show the delta queues in the right order.
660
661 =back
662
663 Complete diff since the last upload:
664
665 =over
666
667     % git diff dgit/dgit/sid..HEAD -- :/ :!/debian/patches
668
669 This includes changes to upstream files.
670
671 =back
672
673 Interdiff of delta queue since last upload, if you really want it:
674
675     % git debrebase make-patches
676     % git diff dgit/dgit/sid..HEAD -- debian/patches
677
678 And of course there is:
679
680     % git debrebase status
681
682 =head2 Alternative ways to start a debrebase
683
684 Above we started an interactive debrebase by invoking git-debrebase(1)
685 like this:
686
687 =over 4
688
689     % git debrebase -i
690
691 =back
692
693 It is also possible to perform a non-interactive rebase, like this:
694
695 =over 4
696
697     % git debrebase -- [git-rebase options...]
698
699 =back
700
701
702 A third alternative is to have git-debrebase(1) shuffle all the Debian
703 changes to the end of your branch, and then manipulate them yourself
704 using git-rebase(1) directly.  For example,
705
706 =over 4
707
708     % git debrebase
709     % git rebase -i HEAD~5      # there are 4 Debian patches
710
711 =back
712
713 If you take this approach, you should be very careful not to start the
714 rebase too early,
715 including before the most recent pseudomerge.
716 git-rebase without a base argument will often
717 start the rebase too early,
718 and should be avoided.
719 Run git-debrebase instead.
720 See also "ILLEGAL OPERATIONS" in git-debrebase(5).
721
722 =head1 SEE ALSO
723
724 dgit(1), dgit(7), git-debrebase(1), git-debrebase(5)
725
726 =head1 AUTHOR
727
728 This tutorial was written and is maintained by Sean Whitton
729 <spwhitton@spwhitton.name>.  It contains contributions from other dgit
730 contributors too - see the dgit copyright file.