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) might introduce unneeded
58 complexity -- for example, you cannot use B<git merge> to incorporate
59 changes from other contributors. For such packages, consider the
60 workflow described in dgit-maint-merge(7).
62 =head1 INITIAL DEBIANISATION
64 This section explains how to start using this workflow with a new
65 package. It should be skipped when converting an existing package to
68 =head2 When upstream tags releases in git
70 Suppose that the latest stable upstream release is 1.2.2, and this has
71 been tagged '1.2.2' by upstream.
75 % git clone -oupstream https://some.upstream/foo.git
77 % git verify-tag 1.2.2
78 % git reset --hard 1.2.2
79 % git branch --unset-upstream
83 The final command detaches your master branch from the upstream
84 remote, so that git doesn't try to push anything there, or merge
85 unreleased upstream commits. To maintain a copy of your packaging
86 branch on B<salsa.debian.org> in addition to B<dgit-repos>, you can do
91 % git remote add -f origin salsa.debian.org:Debian/foo.git
92 % git push --follow-tags -u origin master
96 Now go ahead and Debianise your package. Just make commits on the
97 master branch, adding things in the I<debian/> directory. If you need
98 to patch the upstream source, see "EDITING THE DELTA QUEUE", below.
99 Note that there is no need to maintain a separate 'upstream' branch,
100 unless you also happen to be involved in upstream development. We
101 work with upstream tags rather than any branches, except temporary
102 branches used to prepare patches for forwarding upstream, for example.
104 Finally, you need an orig tarball:
112 See git-deborig(1) if this fails.
114 This tarball is ephemeral and easily regenerated, so we don't commit
115 it anywhere (e.g. with tools like pristine-tar(1)).
117 =head3 Verifying upstream's tarball releases
121 It can be a good idea to compare upstream's released tarballs with the
122 release tags, at least for the first upload of the package. If they
123 are different, you might need to add some additional steps to your
124 I<debian/rules>, such as running autotools.
126 A convenient way to perform this check is to import the tarball as
127 described in the following section, using a different value for
128 'upstream-tag', and then use git-diff(1) to compare the imported
129 tarball to the release tag. If they are the same, you can use
130 upstream's tarball instead of running git-deborig(1).
134 =head2 When upstream releases only tarballs
136 We need a virtual upstream branch with virtual release tags.
137 gbp-import-orig(1) can manage this for us. To begin
147 Now create I<debian/gbp.conf>:
152 upstream-branch = upstream
153 debian-branch = master
154 upstream-tag = %(version)s
158 pristine-tar-commit = False
165 gbp-import-orig(1) requires a pre-existing upstream branch:
169 % git add debian/gbp.conf && git commit -m "create gbp.conf"
170 % git checkout --orphan upstream
172 % git commit --allow-empty -m "initial, empty branch for upstream source"
173 % git checkout -f master
177 Then we can import the upstream version:
181 % gbp import-orig --merge-mode=replace ../foo_1.2.2.orig.tar.xz
185 Our upstream branch cannot be pushed to B<dgit-repos>, but since we
186 will need it whenever we import a new upstream version, we must push
187 it somewhere. The usual choice is B<salsa.debian.org>:
191 % git remote add -f origin salsa.debian.org:Debian/foo.git
192 % git push --follow-tags -u origin master upstream
196 You are now ready to proceed as above, making commits to the
197 I<debian/> directory.
199 =head1 CONVERTING AN EXISTING PACKAGE
201 This section explains how to convert an existing Debian package to
202 this workflow. It should be skipped when debianising a new package.
204 =head2 No existing git history
210 % git remote add -f upstream https://some.upstream/foo.git
214 =head2 Existing git history using another workflow
216 First, if you don't already have the git history locally, clone it,
217 and obtain the corresponding orig.tar from the archive:
221 % git clone salsa.debian.org:Debian/foo
227 If your tree is patches-unapplied, you will need to make a commit
228 corresponding to each of the quilt patches. You can use
232 git debrebase convert-from-gbp
236 or manually with gbp-pq(1):
242 % git merge --ff-only patch-queue/master
247 Then make new upstream tags available:
251 % git remote add -f upstream https://some.upstream/foo.git
255 =for dgit-test dpkg-source-ignores begin
257 Now you simply need to ensure that your git HEAD is dgit-compatible,
258 i.e., it is exactly what you would get if you ran
259 B<dpkg-buildpackage -i'(?:^|/)\.git(?:/|$)' -I.git -S>
260 and then unpacked the resultant source package.
262 =for dgit-test dpkg-source-ignores end
264 To achieve this, you might need to delete
265 I<debian/source/local-options>. One way to have dgit check your
266 progress is to run B<dgit build-source>.
268 The first dgit push will require I<--overwrite>. If this is the first
269 ever dgit push of the package, consider passing
270 I<--deliberately-not-fast-forward> instead of I<--overwrite>. This
271 avoids introducing a new origin commit into your git history. (This
272 origin commit would represent the most recent non-dgit upload of the
273 package, but this should already be represented in your git history.)
274 =head1 GIT CONFIGURATION
276 This workflow does not support using B<git merge> to merge divergent
277 branches of development (see "OTHER MERGES" in git-debrebase(5)). You
278 should configure git such that B<git pull> does not try to merge:
282 % git config --local pull.rebase true
286 Now when you pull work from other Debian contributors, git will rebase
287 your work on top of theirs.
289 If you use this repository for upstream development in addition to
290 Debian packaging work, you may not want to set this global setting.
291 Instead, see the B<branch.autoSetupRebase> and
292 B<branch.E<lt>nameE<gt>.rebase> settings in git-config(5).
294 =head1 IMPORTING NEW UPSTREAM RELEASES
296 =head2 Obtaining the release
298 =head3 When upstream tags releases in git
306 =head3 When upstream releases only tarballs
308 You will need the I<debian/gbp.conf> from "When upstream releases only
309 tarballs", above. You will also need your upstream branch. Above, we
310 pushed this to B<salsa.debian.org>. You will need to clone or fetch
311 from there, instead of relying on B<dgit clone>/B<dgit fetch> alone.
317 % gbp import-orig --no-merge ../foo_1.2.3.orig.tar.xz
321 or if you have a working watch file
325 % gbp import-orig --no-merge --uscan
329 =head2 Importing the release
333 % git debrebase new-upstream-v0 1.2.3
334 % dch -v1.2.3-1 New upstream release.
335 % git add debian/changelog && git commit -m changelog
339 You can now review the merge of the new upstream release:
343 git diff debian/1.2.2-1..HEAD -- . ':!debian'
347 Pass I<--stat> just to see the list of changed files, which is useful
348 to determine whether there are any new or deleted files to may need
349 accounting for in your copyright file.
351 If you obtained a tarball from upstream, you are ready to try a build.
352 If you merged a git tag from upstream, you will first need to generate
361 =head1 EDITING THE DELTA QUEUE
363 =head2 Adding new patches
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-cherrypick(1).
369 =head2 Editing patches: starting a debrebase
371 git-debrebase(1) is a wrapper around git-rebase(1) which allows us to
372 edit, re-order and delete patches. Run
380 to start an interactive rebase. You can edit, re-order and delete
381 commits just as you would during B<git rebase -i>. Alternatively, you
382 can perform a non-interactive rebase like this:
386 % git debrebase -- [git-rebase options...]
390 A third alternative is to have git-debrebase(1) shuffle all the Debian
391 changes to the end of your branch, and then manipulate them yourself
392 using git-rebase(1). For example,
396 % git debrebase launder
397 % git rebase -i HEAD~5 # there are 4 Debian patches
401 If you take this approach, you should be very careful not to start the
402 rebase earlier than the beginning of the delta queue.
404 =head2 Editing patches: finishing a debrebase
406 After completing the git rebase, your branch will not be a
407 fast-forward of the git HEAD you had before the rebase. This means
408 that we cannot push the branch anywhere. If you are ready to upload,
409 B<dgit push> or B<dgit push-source> will take care of fixing this up
412 If you are not yet ready to upload, and want to push your branch to a
413 git remote such as B<salsa.debian.org>,
417 % git debrebase launder
418 % git debrebase stitch
422 Note that each time you stitch a debrebase you introduce a pseudomerge
423 into your git history, which may make it harder to read. Try to do
424 all of the editing of the delta queue that you think will be needed
425 for this upload in a single debrebase, so that there is a single
428 A strategy is to debrebase only right before you upload. Before that
429 point, instead of editing the existing delta queue, you append fixup
430 commits (and reversions of commits) that alter the upstream source to
431 the required state. You can freely push and pull from
432 B<salsa.debian.org> during this. Just before uploading, you debrebase
433 to tidy everything up.
435 =head1 BUILDING AND UPLOADING
437 Use B<dgit build>, B<dgit sbuild>, B<dgit push> and B<dgit
438 push-source> as detailed in dgit(1). If any command fails, dgit will
439 provide a carefully-worded error message explaining what you should
440 do. If it's not clear, file a bug against dgit. Remember to pass
441 I<--new> for the first upload.
443 After dgit pushing, be sure to git push to B<salsa.debian.org>, if
446 As an alternative to B<dgit build> and friends, you can use a tool
447 like gitpkg(1). This works because like dgit, gitpkg(1) enforces that
448 HEAD has exactly the contents of the source package. gitpkg(1) is
449 highly configurable, and one dgit user reports using it to produce and
450 test multiple source packages, from different branches corresponding
451 to each of the current Debian suites.
453 If you want to skip dgit's checks while iterating on a problem with
454 the package build (for example, you don't want to commit your changes
455 to git), you can just run dpkg-buildpackage(1) or debuild(1) instead.
457 =head2 Laundering the delta queue before uploading
459 Just before you B<dgit push> or B<dgit push-source>, you might want to
460 have git-debrebase(1) shuffle your branch such that the Debian delta
461 queue appears at the end:
465 % git debrebase launder
470 Note that this will introduce a new pseudomerge.
472 =head1 HANDLING DFSG-NON-FREE MATERIAL
474 This covers only DFSG-non-free material. Material which is legally
475 dangerous (for example, files which are actually illegal) cannot be
478 If you encounter possibly-legally-dangerous material in the upstream
479 source code you should seek advice. It is often best not to make a
480 fuss on a public mailing list (at least, not at first). Instead,
481 email your archive administrators. For Debian that is
482 To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org
484 =head2 When upstream tags releases in git
486 We create a DFSG-clean tag to import to master:
490 % git checkout -b pre-dfsg 1.2.3
492 % git commit -m "upstream version 1.2.3 DFSG-cleaned"
493 % git tag -s 1.2.3+dfsg
494 % git checkout master
495 % git branch -D pre-dfsg
499 =head2 When upstream releases only tarballs
501 The easiest way to handle this is to add a B<Files-Excluded> field to
502 I<debian/copyright>, and a B<uversionmangle> setting in
503 I<debian/watch>. See uscan(1). Alternatively, see the I<--filter>
504 option detailed in gbp-import-orig(1).
506 =head1 INCORPORATING NMUS
508 In the simplest case,
513 % git merge --ff-only dgit/dgit/sid
517 If that fails, because your branch and the NMUers work represent
518 divergent branches of development, you have a number of options. Here
519 we describe the two simplest.
521 =head2 Rebasing your work onto the NMU
525 % git rebase dgit/dgit/sid
529 If the NMUer added new commits modifying the upstream source, you will
530 probably want to debrebase before your next upload to tidy those up.
532 For example, the NMUer might have used git-revert(1) to unapply one of
533 your patches. A debrebase will strip both the patch and the reversion
534 from the delta queue.
536 =head2 Manually applying the debdiff
538 If you cannot rebase because you have already pushed to
539 B<salsa.debian.org>, say, you can manually apply the NMU debdiff,
540 commit and debrebase. The next B<dgit push> will require
549 This tutorial was written and is maintained by Sean Whitton
550 <spwhitton@spwhitton.name>. It contains contributions from other dgit
551 contributors too - see the dgit copyright file.