3 dgit - tutorial for package maintainers, using a workflow centered around git-debrebase(1)
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.
14 Some advantages of this workflow:
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).
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)).
33 Avoid the git tree being dirtied by the application or unapplication
34 of patches, as they are always applied.
38 Benefit from dgit's safety catches. In particular, ensure that your
39 upload always matches exactly your git HEAD.
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)).
49 Minimise the amount you need to know about 3.0 (quilt) in order to
50 maintain Debian source packages which use that format.
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
61 =head1 INITIAL DEBIANISATION
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
67 =head2 When upstream tags releases in git
69 Suppose that the latest stable upstream release is 1.2.2, and this has
70 been tagged '1.2.2' by upstream.
74 % git clone -oupstream https://some.upstream/foo.git
76 % git verify-tag 1.2.2
77 % git reset --hard 1.2.2
78 % git branch --unset-upstream
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
90 % git remote add -f origin salsa.debian.org:Debian/foo.git
91 % git push --follow-tags -u origin master
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.
102 Finally, you need an orig tarball:
110 See git-deborig(1) if this fails.
112 This tarball is ephemeral and easily regenerated, so we don't commit
113 it anywhere (e.g. with tools like pristine-tar(1)).
115 =head3 Comparing upstream's tarball releases
119 It can be a good idea to compare upstream's released tarballs with the
120 release tags, at least for the first upload of the package. If they
121 are different, you might need to add some additional steps to your
122 I<debian/rules>, such as running autotools.
124 A convenient way to perform this check is to import the tarball as
125 described in the following section, using a different value for
126 'upstream-tag', and then use git-diff(1) to compare the imported
127 tarball to the release tag. If they are the same, you can use
128 upstream's tarball instead of running git-deborig(1).
132 =head2 When upstream releases only tarballs
134 We need a virtual upstream branch with virtual release tags.
135 gbp-import-orig(1) can manage this for us. To begin
145 Now create I<debian/gbp.conf>:
150 upstream-branch = upstream
151 debian-branch = master
152 upstream-tag = %(version)s
156 pristine-tar-commit = False
163 gbp-import-orig(1) requires a pre-existing upstream branch:
167 % git add debian/gbp.conf && git commit -m "create gbp.conf"
168 % git checkout --orphan upstream
170 % git commit --allow-empty -m "initial, empty branch for upstream source"
171 % git checkout -f master
175 Then we can import the upstream version:
179 % gbp import-orig --merge-mode=replace ../foo_1.2.2.orig.tar.xz
183 Our upstream branch cannot be pushed to B<dgit-repos>, but since we
184 will need it whenever we import a new upstream version, we must push
185 it somewhere. The usual choice is B<salsa.debian.org>:
189 % git remote add -f origin salsa.debian.org:Debian/foo.git
190 % git push --follow-tags -u origin master upstream
194 You are now ready to proceed as above, making commits to the
195 I<debian/> directory and to the upstream source. As above, for
196 technical reasons, B<it is essential that your first commit introduces
197 the debian/ directory containing at least one file, and does nothing
198 else.> In other words, make a commit introducing I<debian/> before
199 patching the upstream source.
202 =head1 CONVERTING AN EXISTING PACKAGE
204 This section explains how to convert an existing Debian package to
205 this workflow. It should be skipped when debianising a new package.
207 =head2 No existing git history
213 % git remote add -f upstream https://some.upstream/foo.git
217 =head2 Existing git history using another workflow
219 First, if you don't already have the git history locally, clone it,
220 and obtain the corresponding orig.tar from the archive:
224 % git clone salsa.debian.org:Debian/foo
230 If your tree is patches-unapplied, you will need to make a commit
231 corresponding to each of the quilt patches. You can use
235 git debrebase convert-from-gbp
239 or manually with gbp-pq(1):
245 % git merge --ff-only patch-queue/master
250 Then make new upstream tags available:
254 % git remote add -f upstream https://some.upstream/foo.git
258 =for dgit-test dpkg-source-ignores begin
260 Now you simply need to ensure that your git HEAD is dgit-compatible,
261 i.e., it is exactly what you would get if you ran
262 B<dpkg-buildpackage -i'(?:^|/)\.git(?:/|$)' -I.git -S>
263 and then unpacked the resultant source package.
265 =for dgit-test dpkg-source-ignores end
267 To achieve this, you might need to delete
268 I<debian/source/local-options>. One way to have dgit check your
269 progress is to run B<dgit build-source>.
271 The first dgit push will require I<--overwrite>.
273 =head1 GIT CONFIGURATION
275 This workflow does not support using B<git merge> to merge divergent
276 branches of development (see "OTHER MERGES" in git-debrebase(5)). You
277 should configure git such that B<git pull> does not try to merge:
281 % git config --local pull.rebase true
285 Now when you pull work from other Debian contributors, git will rebase
286 your work on top of theirs.
288 If you use this repository for upstream development in addition to
289 Debian packaging work, you may not want to set this global setting.
290 Instead, see the B<branch.autoSetupRebase> and
291 B<branch.E<lt>nameE<gt>.rebase> settings in git-config(5).
293 =head1 IMPORTING NEW UPSTREAM RELEASES
295 There are two steps: obtaining git refs that correspond to the new
296 release, and importing that release using git-debrebase(1).
298 =head2 Obtaining the release
300 =head3 When upstream tags releases in git
308 =head3 When upstream releases only tarballs
310 You will need the I<debian/gbp.conf> from "When upstream releases only
311 tarballs", above. You will also need your upstream branch. Above, we
312 pushed this to B<salsa.debian.org>. You will need to clone or fetch
313 from there, instead of relying on B<dgit clone>/B<dgit fetch> alone.
319 % gbp import-orig --no-merge ../foo_1.2.3.orig.tar.xz
323 or if you have a working watch file
327 % gbp import-orig --no-merge --uscan
331 =head2 Importing the release
335 % git debrebase new-upstream-v0 1.2.3
336 % dch -v1.2.3-1 New upstream release.
337 % git add debian/changelog && git commit -m changelog
341 You can now review the merge of the new upstream release:
345 git diff debian/1.2.2-1..HEAD -- . ':!debian'
349 Pass I<--stat> just to see the list of changed files, which is useful
350 to determine whether there are any new or deleted files to may need
351 accounting for in your copyright file.
353 If you obtained a tarball from upstream, you are ready to try a build.
354 If you merged a git tag from upstream, you will first need to generate
363 =head1 EDITING THE DELTA QUEUE
365 =head2 Adding new patches
367 Adding new patches is straightforward: just make commits touching only
368 files outside of the I<debian/> directory. You can also use tools
369 like git-revert(1), git-am(1) and git-cherrypick(1).
371 =head2 Editing patches: starting a debrebase
373 git-debrebase(1) is a wrapper around git-rebase(1) which allows us to
374 edit, re-order and delete patches. Run
382 to start an interactive rebase. You can edit, re-order and delete
383 commits just as you would during B<git rebase -i>.
385 =head2 Editing patches: finishing a debrebase
387 After completing the git rebase, your branch will not be a
388 fast-forward of the git HEAD you had before the rebase. This means
389 that we cannot push the branch anywhere. If you are ready to upload,
390 B<dgit push> or B<dgit push-source> will take care of fixing this up
393 If you are not yet ready to upload, and want to push your branch to a
394 git remote such as B<salsa.debian.org>,
398 % git debrebase conclude
402 Note that each time you conclude a debrebase you introduce a
403 pseudomerge into your git history, which may make it harder to read.
404 Try to do all of the editing of the delta queue that you think will be
405 needed for this upload in a single debrebase, so that there is a
406 single debrebase stitch.
408 =head1 BUILDING AND UPLOADING
410 You can use dpkg-buildpackage(1) for test builds. When you are ready
411 to build for an upload, use B<dgit sbuild>.
413 Upload with B<dgit push> or B<dgit push-source>. Remember to pass
414 I<--new> if the package is new in the target suite.
416 Right before uploading, if you did not just already do so, you might
417 want to have git-debrebase(1) shuffle your branch such that the Debian
418 delta queue appears right at the tip of the branch you will push:
422 % git debrebase launder
427 Note that this will introduce a new pseudomerge.
429 After dgit pushing, be sure to git push to B<salsa.debian.org>, if
432 =head1 HANDLING DFSG-NON-FREE MATERIAL
434 This covers only DFSG-non-free material. Material which is legally
435 dangerous (for example, files which are actually illegal) cannot be
438 If you encounter possibly-legally-dangerous material in the upstream
439 source code you should seek advice. It is often best not to make a
440 fuss on a public mailing list (at least, not at first). Instead,
441 email your archive administrators. For Debian that is
442 To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org
444 =head2 When upstream tags releases in git
446 We create a DFSG-clean tag to import to master:
450 % git checkout -b pre-dfsg 1.2.3
452 % git commit -m "upstream version 1.2.3 DFSG-cleaned"
453 % git tag -s 1.2.3+dfsg
454 % git checkout master
455 % git branch -D pre-dfsg
459 =head2 When upstream releases only tarballs
461 The easiest way to handle this is to add a B<Files-Excluded> field to
462 I<debian/copyright>, and a B<uversionmangle> setting in
463 I<debian/watch>. See uscan(1). Alternatively, see the I<--filter>
464 option detailed in gbp-import-orig(1).
466 =head1 INCORPORATING NMUS
468 In the simplest case,
473 % git merge --ff-only dgit/dgit/sid
477 If that fails, because your branch and the NMUers work represent
478 divergent branches of development, you have a number of options. Here
479 we describe the two simplest.
481 =head2 Rebasing your work onto the NMU
485 % git rebase dgit/dgit/sid
489 If the NMUer added new commits modifying the upstream source, you will
490 probably want to debrebase before your next upload to tidy those up.
492 For example, the NMUer might have used git-revert(1) to unapply one of
493 your patches. A debrebase will strip both the patch and the reversion
494 from the delta queue.
496 =head2 Manually applying the debdiff
498 If you cannot rebase because you have already pushed to
499 B<salsa.debian.org>, say, you can manually apply the NMU debdiff,
500 commit and debrebase. The next B<dgit push> will require
503 =head1 HINTS AND TIPS
505 =head2 Minimising pseudomerges
507 Above we noted that each time you conclude a debrebase, you introduce
508 a pseudomerge into your git history, which may make it harder to read.
510 A convention you can use to minimise the number of pseudomerges is to
511 debrebase only right before you upload.
513 Before that point, instead of editing the existing delta queue, you
514 append fixup commits (and reversions of commits) that alter the
515 upstream source to the required state. You can freely push and pull
516 from B<salsa.debian.org> during this. Just before uploading, you
517 debrebase, once, to tidy everything up.
519 =head2 Upstream branches
521 Except in the case where upstream releases only tarballs, we do not
522 maintain a separate 'upstream' branch (unless you also happen to be
523 involved in upstream development). We work with upstream tags rather
524 than any branches, except temporary branches used to prepare patches
525 for forwarding upstream, for example.
527 The thought behind this is that branches are things to which one
528 expects to commit, while tags are immutable points in history. From
529 the Debian point of the view, the upstream source is immutable. It's
530 our packaging to which we expect to commit.
532 =head2 The first ever dgit push
534 If this is the first ever dgit push of the package, consider passing
535 I<--deliberately-not-fast-forward> instead of I<--overwrite>. This
536 avoids introducing a new origin commit into your git history. (This
537 origin commit would represent the most recent non-dgit upload of the
538 package, but this should already be represented in your git history.)
540 =head2 Alternative ways to start a debrebase
542 Above we started an interactive debrebase by invoking git-debrebase(1)
543 without any arguments, i.e.
551 It is also possible to perform a non-interactive rebase, like this:
555 % git debrebase -- [git-rebase options...]
560 A third alternative is to have git-debrebase(1) shuffle all the Debian
561 changes to the end of your branch, and then manipulate them yourself
562 using git-rebase(1) directly. For example,
566 % git debrebase launder
567 % git rebase -i HEAD~5 # there are 4 Debian patches
571 If you take this approach, you should be very careful not to start the
572 rebase earlier than the beginning of the delta queue.
580 This tutorial was written and is maintained by Sean Whitton
581 <spwhitton@spwhitton.name>. It contains contributions from other dgit
582 contributors too - see the dgit copyright file.