1dgit-maint-debrebase(7)              dgit              dgit-maint-debrebase(7)
2
3
4

NAME

6       dgit - tutorial for package maintainers, using a workflow centered
7       around git-debrebase(1)
8

INTRODUCTION

10       This document describes elements of a workflow for maintaining a non-
11       native Debian package using dgit.  We maintain the Debian delta as a
12       series of git commits on our master branch.  We use git-debrebase(1) to
13       shuffle our branch such that this series of git commits appears at the
14       end of the branch.  All the public git history is fast-forwarding,
15       i.e., we do not rewrite and force-push.
16
17       Some advantages of this workflow:
18
19       •   Manipulate the delta queue using the full power of git-rebase(1),
20           instead of relying on quilt(1), and without having to switch back
21           and forth between patches-applied and patches-unapplied branches
22           when committing changes and trying to build, as with gbp-pq(1).
23
24       •   If you are using 3.0 (quilt), provide your delta queue as a
25           properly separated series of quilt patches in the source package
26           that you upload to the archive (unlike with dgit-maint-merge(7)).
27
28       •   Avoid the git tree being dirtied by the application or
29           unapplication of patches, as they are always applied.
30
31       •   Benefit from dgit's safety catches.  In particular, ensure that
32           your upload always matches exactly your git HEAD.
33
34       •   Provide your full git history in a standard format on dgit-repos,
35           where it can benefit downstream dgit users, such as people using
36           dgit to do an NMU (see dgit-nmu-simple(7) and dgit-user(7)).
37
38       •   Minimise the amount you need to know about 3.0 (quilt) in order to
39           maintain Debian source packages which use that format.
40
41       This workflow is appropriate for packages where the Debian delta
42       contains multiple pieces which interact, or which you don't expect to
43       be able to upstream soon.  For packages with simple and/or short-lived
44       Debian deltas, use of git-debrebase(1) introduces unneeded complexity.
45       For such packages, consider the workflow described in
46       dgit-maint-merge(7).
47

INITIAL DEBIANISATION

49       This section explains how to start using this workflow with a new
50       package.  It should be skipped when converting an existing package to
51       this workflow.
52
53   When upstream tags releases in git
54       Suppose that the latest stable upstream release is 1.2.2, and this has
55       been tagged '1.2.2' by upstream.
56
57           % git clone -oupstream https://some.upstream/foo.git
58           % cd foo
59           % git verify-tag 1.2.2
60           % git reset --hard 1.2.2
61           % git branch --unset-upstream
62
63       The final command detaches your master branch from the upstream remote,
64       so that git doesn't try to push anything there, or merge unreleased
65       upstream commits.  To maintain a copy of your packaging branch on
66       salsa.debian.org in addition to dgit-repos, you can do something like
67       this:
68
69           % git remote add -f origin salsa.debian.org:Debian/foo.git
70           % git push --follow-tags -u origin master
71
72       Now go ahead and Debianise your package.  Make commits on the master
73       branch, adding things in the debian/ directory, or patching the
74       upstream source.  For technical reasons, it is essential that your
75       first commit introduces the debian/ directory containing at least one
76       file, and does nothing else. In other words, make a commit introducing
77       debian/ before patching the upstream source.
78
79       Finally, you need an orig tarball:
80
81           % git deborig
82
83       See git-deborig(1) if this fails.
84
85       This tarball is ephemeral and easily regenerated, so we don't commit it
86       anywhere (e.g. with tools like pristine-tar(1)).
87
88       Comparing upstream's tarball releases
89
90           The above assumes that you know how to build the package from git
91           and that doing so is straightforward.
92
93           If, as a user of the upstream source, you usually build from
94           upstream tarball releases, rather than upstream git tags, you will
95           sometimes find that the git tree doesn't contain everything that is
96           in the tarball.
97
98           Additional build steps may be needed.  For example, you may need
99           your debian/rules to run autotools.
100
101           You can compare the upstream tarball release, and upstream git tag,
102           within git, by importing the tarball into git as described in the
103           next section, using a different value for 'upstream-tag', and then
104           using git-diff(1) to compare the imported tarball to the release
105           tag.
106
107       Using untagged upstream commits
108
109           Sometimes upstream does not tag their releases, or you want to
110           package an unreleased git snapshot.  In such a case you can create
111           your own upstream release tag, of the form upstream/ver, where ver
112           is the upstream version you plan to put in debian/changelog.  The
113           upstream/ prefix ensures that your tag will not clash with any tags
114           upstream later creates.
115
116           For example, suppose that the latest upstream release is 1.2.2 and
117           you want to package git commit ab34c21 which was made on
118           2013-12-11.  A common convention is to use the upstream version
119           number 1.2.2+git20131211.ab34c21 and so you could use
120
121               % git tag -s upstream/1.2.2+git20131211.ab34c21 ab34c21
122
123           to obtain a release tag, and then proceed as above.
124
125   When upstream releases only tarballs
126       Because we want to work in git, we need a virtual upstream branch with
127       virtual release tags.  gbp-import-orig(1) can manage this for us.  To
128       begin
129
130           % mkdir foo
131           % cd foo
132           % git init
133           % git checkout -b upstream
134           % gbp import-orig \
135               --upstream-branch=upstream --debian-branch=master \
136               --upstream-tag='upstream/%(version)s' \
137               --sign-tags --no-pristine-tar \
138               ../foo_1.2.2.orig.tar.xz
139           % git branch -f upstream
140
141       This should leave you on the master branch.  Next, our upstream branch
142       cannot be pushed to dgit-repos, but since we will need it whenever we
143       import a new upstream version, we must push it somewhere.  The usual
144       choice is salsa.debian.org:
145
146           % git remote add -f origin salsa.debian.org:Debian/foo.git
147           % git push --follow-tags -u origin master upstream
148
149       You are now ready to proceed as above, making commits to the debian/
150       directory and to the upstream source.  As above, for technical reasons,
151       it is essential that your first commit introduces the debian/ directory
152       containing at least one file, and does nothing else.  In other words,
153       make a commit introducing debian/ before patching the upstream source.
154
155       A convenient way to ensure this requirement is satisfied is to start by
156       creating debian/gbp.conf:
157
158           [DEFAULT]
159           upstream-branch = upstream
160           debian-branch = master
161           upstream-tag = upstream/%(version)s
162
163           sign-tags = True
164           pristine-tar = False
165           pristine-tar-commit = False
166
167           [import-orig]
168           merge = False
169
170       and commit that:
171
172           % git add debian/gbp.conf && git commit -m "create gbp.conf"
173
174       Note that we couldn't create debian/gbp.conf before now for the same
175       technical reasons which require our first commit to introduce debian/
176       without patching the upstream source.  That's why we had to pass a lot
177       of options to our first call to gbp-import-orig(1).
178

CONVERTING AN EXISTING PACKAGE

180       This section explains how to convert an existing Debian package to this
181       workflow.  It should be skipped when debianising a new package.
182
183       If you have an existing git history that you have pushed to an ordinary
184       git server like salsa.debian.org, we start with that.  If you don't
185       already have it locally, you'll need to clone it, and obtain the
186       corresponding orig.tar from the archive:
187
188           % git clone salsa.debian.org:Debian/foo
189           % cd foo
190           % dgit setup-new-tree
191           % origtargz
192
193       If you don't have any existing git history, or you have history only on
194       the special dgit-repos server, we start with dgit clone:
195
196           % dgit clone foo
197           % cd foo
198
199       Then we make new upstream tags available:
200
201           % git remote add -f upstream https://some.upstream/foo.git
202
203       We now use a git debrebase convert-from-* command to convert your
204       existing history to the git-debrebase(5) data model.  Which command you
205       should use depends on some facts about your repository:
206
207       (A) There is no delta queue.
208           If there do not exist any Debian patches, use
209
210               % git debrebase convert-from-gbp
211
212       (B) There is a delta queue, and patches are unapplied.
213           This is the standard git-buildpackage(1) workflow: there are Debian
214           patches, but the upstream source is committed to git without those
215           patches applied.  Use
216
217               % git debrebase convert-from-gbp
218
219           If you were not previously using dgit to upload your package (i.e.
220           you were not using the workflow described in dgit-maint-gbp(7)),
221           and you happen to have run dgit fetch sid in this clone of the
222           repository, you will need to pass --fdiverged to this command.
223
224       (C) There is a delta queue, and patches are applied.
225           Use
226
227               % git debrebase convert-from-dgit-view
228
229       Finally, you need to ensure that your git HEAD is dgit-compatible,
230       i.e., it is exactly what you would get if you deleted .git, invoked
231       dpkg-buildpackage -S, and then unpacked the resultant source package.
232
233       To achieve this, you might need to delete debian/source/local-options.
234       One way to have dgit check your progress is to run dgit build-source.
235

GIT CONFIGURATION

237       git-debrebase(1) does not yet support using git merge to merge
238       divergent branches of development (see "OTHER MERGES" in
239       git-debrebase(5)).  You should configure git such that git pull does
240       not try to merge:
241
242           % git config --local pull.rebase true
243
244       Now when you pull work from other Debian contributors, git will rebase
245       your work on top of theirs.
246
247       If you use this clone for upstream development in addition to Debian
248       packaging work, you may not want to set this global setting.  Instead,
249       see the branch.autoSetupRebase and branch.<name>.rebase settings in
250       git-config(5).
251

IMPORTING NEW UPSTREAM RELEASES

253       There are two steps: obtaining git refs that correspond to the new
254       release, and importing that release using git-debrebase(1).
255
256   Obtaining the release
257       When upstream tags releases in git
258
259           % git fetch --tags upstream
260
261       If you want to package an untagged upstream commit (because upstream
262       does not tag releases or because you want to package an upstream
263       development snapshot), see "Using untagged upstream commits" above.
264
265       When upstream releases only tarballs
266
267       You will need the debian/gbp.conf from "When upstream releases only
268       tarballs", above.  You will also need your upstream branch.  Above, we
269       pushed this to salsa.debian.org.  You will need to clone or fetch from
270       there, instead of relying on dgit clone/dgit fetch alone.
271
272       Then, either
273
274           % gbp import-orig ../foo_1.2.3.orig.tar.xz
275
276       or if you have a working watch file
277
278           % gbp import-orig --uscan
279
280   Importing the release
281           % git debrebase new-upstream 1.2.3
282
283       This invocation of git-debrebase(1) involves a git rebase.  You may
284       need to resolve conflicts if the Debian delta queue does not apply
285       cleanly to the new upstream source.
286
287       If all went well, you can now review the merge of the new upstream
288       release:
289
290           git diff debian/1.2.2-1..HEAD -- . ':!debian'
291
292       Also, diff with --name-status and --diff-filter=ADR to see just the
293       list of added or removed files, which is useful to determine whether
294       there are any new or deleted files that may need accounting for in your
295       copyright file.
296
297       If you obtained a tarball from upstream, you are ready to try a build.
298       If you merged a git tag from upstream, you will first need to generate
299       a tarball:
300
301           % git deborig
302

EDITING THE DEBIAN PACKAGING

304       Just make commits on master that change the contents of debian/.
305

EDITING THE DELTA QUEUE

307   Adding new patches
308       Adding new patches is straightforward: just make commits touching only
309       files outside of the debian/ directory.  You can also use tools like
310       git-revert(1), git-am(1) and git-cherry-pick(1).
311
312   Editing patches: starting a debrebase
313       git-debrebase(1) is a wrapper around git-rebase(1) which allows us to
314       edit, re-order and delete patches.  Run
315
316           % git debrebase -i
317
318       to start an interactive rebase.  You can edit, re-order and delete
319       commits just as you would during git rebase -i.
320
321   Editing patches: finishing a debrebase
322       After completing the git rebase, your branch will not be a fast-forward
323       of the git HEAD you had before the rebase.  This means that we cannot
324       push the branch anywhere.  If you are ready to upload, dgit push or
325       dgit push-source will take care of fixing this up for you.
326
327       If you are not yet ready to upload, and want to push your branch to a
328       git remote such as salsa.debian.org,
329
330           % git debrebase conclude
331
332       Note that each time you conclude a debrebase you introduce a
333       pseudomerge into your git history, which may make it harder to read.
334       Try to do all of the editing of the delta queue that you think will be
335       needed for this editing session in a single debrebase, so that there is
336       a single debrebase stitch.
337

BUILDING AND UPLOADING

339       You can use dpkg-buildpackage(1) for test builds.  When you are ready
340       to build for an upload, use dgit sbuild, dgit pbuilder or dgit
341       cowbuilder.
342
343       Upload with dgit push or dgit push-source.  Remember to pass --new if
344       the package is new in the target suite.
345
346       In some cases where you used git debrebase convert-from-gbp since the
347       last upload, it is not possible for dgit to make your history fast-
348       forwarding from the history on dgit-repos.  In such cases you will have
349       to pass --overwrite to dgit.  git-debrebase will normally tell you if
350       this will be needed.
351
352       If you want to upload with git-debpush(1), for the first upload you
353       should pass the --quilt=linear quilt mode option (see git-debpush(1)).
354
355       Right before uploading, if you did not just already do so, you might
356       want to have git-debrebase(1) shuffle your branch such that the Debian
357       delta queue appears right at the tip of the branch you will push:
358
359           % git debrebase
360           % dgit push-source
361
362       Note that this will introduce a new pseudomerge.
363
364       After dgit pushing, be sure to git push to salsa.debian.org, if you're
365       using that.
366

HANDLING DFSG-NON-FREE MATERIAL

368   Illegal material
369       Here we explain how to handle material that is merely DFSG-non-free.
370       Material which is legally dangerous (for example, files which are
371       actually illegal) cannot be handled this way.
372
373       If you encounter possibly-legally-dangerous material in the upstream
374       source code you should seek advice.  It is often best not to make a
375       fuss on a public mailing list (at least, not at first).  Instead, email
376       your archive administrators.  For Debian that is
377        To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org
378
379   DFSG-non-free: When upstream tags releases in git
380       Our approach is to maintain a DFSG-clean upstream branch, and create
381       tags on this branch for each release that we want to import.  We then
382       import those tags per "Importing the release", above.  In the case of a
383       new package, we base our initial Debianisation on our first DFSG-clean
384       tag.
385
386       For the first upstream release that requires DFSG filtering:
387
388           % git checkout -b upstream-dfsg 1.2.3
389           % git rm evil.bin
390           % git commit -m "upstream version 1.2.3 DFSG-cleaned"
391           % git tag -s 1.2.3+dfsg
392           % git checkout master
393
394       Now either proceed with "Importing the release" on the 1.2.3+dfsg tag,
395       or in the case of a new package,
396
397           % git branch --unset-upstream
398           % git reset --hard 1.2.3+dfsg
399
400       and proceed with "INITIAL DEBIANISATION".
401
402       For subsequent releases (whether or not they require additional
403       filtering):
404
405           % git checkout upstream-dfsg
406           % git merge 1.2.4
407           % git rm further-evil.bin # if needed
408           % git commit -m "upstream version 1.2.4 DFSG-cleaned" # if needed
409           % git tag -s 1.2.4+dfsg
410           % git checkout master
411           % # proceed with "Importing the release" on 1.2.4+dfsg tag
412
413       Our upstream-dfsg branch cannot be pushed to dgit-repos, but since we
414       will need it whenever we import a new upstream version, we must push it
415       somewhere.  Assuming that you have already set up an origin remote per
416       the above,
417
418           % git push --follow-tags -u origin master upstream-dfsg
419
420   DFSG-non-free: When upstream releases only tarballs
421       The easiest way to handle this is to add a Files-Excluded field to
422       debian/copyright, and a uversionmangle setting in debian/watch.  See
423       uscan(1).  Alternatively, see the --filter option detailed in
424       gbp-import-orig(1).
425

INCORPORATING NMUS

427       In the simplest case,
428
429           % dgit fetch
430           % git merge --ff-only dgit/dgit/sid
431
432       If that fails, because your branch and the NMUers' work represent
433       divergent branches of development, you have a number of options.  Here
434       we describe the two simplest.
435
436       Note that you should not try to resolve the divergent branches by
437       editing files in debian/patches.  Changes there would either cause
438       trouble, or be overwritten by git-debrebase(1).
439
440   Rebasing your work onto the NMU
441           % git rebase dgit/dgit/sid
442
443       If the NMUer added new commits modifying the upstream source, you will
444       probably want to debrebase before your next upload to tidy those up.
445
446       For example, the NMUer might have used git-revert(1) to unapply one of
447       your patches.  A debrebase can be used to strip both the patch and the
448       reversion from the delta queue.
449
450   Manually applying the debdiff
451       If you cannot rebase because you have already pushed to
452       salsa.debian.org, say, you can manually apply the NMU debdiff, commit
453       and debrebase.  The next dgit push will require --overwrite.
454

HINTS AND TIPS

456   Minimising pseudomerges
457       Above we noted that each time you conclude a debrebase, you introduce a
458       pseudomerge into your git history, which may make it harder to read.
459
460       A simple convention you can use to minimise the number of pseudomerges
461       is to git debrebase conclude only right before you upload or push to
462       salsa.debian.org.
463
464       It is possible, though much less convenient, to reduce the number of
465       pseudomerges yet further.  We debrebase only (i) when importing a new
466       release, and (ii) right before uploading.  Instead of editing the
467       existing delta queue, you append fixup commits (and reversions of
468       commits) that alter the upstream source to the required state.  You can
469       push and pull to and from salsa.debian.org during this.  Just before
470       uploading, you debrebase, once, to tidy everything up.
471
472   The debian/patches directory
473       In this workflow, debian/patches is purely an output of
474       git-debrebase(1).  You should not make changes there.  They will either
475       cause trouble, or be ignored and overwritten by git-debrebase(1).
476
477       debian/patches will often be out-of-date because git-debrebase(1) will
478       only regenerate it when it needs to.  So you should not rely on the
479       information in that directory.  When preparing patches to forward
480       upstream, you should use git-format-patch(1) on git commits, rather
481       than sending files from debian/patches.
482
483   Upstream branches
484       In this workflow, we specify upstream tags rather than any branches.
485
486       Except when (i) upstream releases only tarballs, (ii) we require DFSG
487       filtering, or (iii) you also happen to be involved in upstream
488       development, we do not maintain any local branch corresponding to
489       upstream, except temporary branches used to prepare patches for
490       forwarding, and the like.
491
492       The idea here is that from Debian's point of view, upstream releases
493       are immutable points in history.  We want to make sure that we are
494       basing our Debian package on a properly identified upstream version,
495       rather than some arbitrary commit on some branch.  Tags are more useful
496       for this.
497
498       Upstream's branches remain available as the git remote tracking
499       branches for your upstream remote, e.g. remotes/upstream/master.
500
501   The first ever dgit push
502       If this is the first ever dgit push of the package, consider passing
503       --deliberately-not-fast-forward instead of --overwrite.  This avoids
504       introducing a new origin commit into your git history.  (This origin
505       commit would represent the most recent non-dgit upload of the package,
506       but this should already be represented in your git history.)
507
508   Inspecting the history
509       The git history made by git-debrebase can seem complicated.  Here are
510       some suggestions for helpful invocations of gitk and git.  They can be
511       adapted for other tools like tig(1), git-log(1), magit, etc.
512
513       History of package in Debian, disregarding history from upstream:
514
515           % gitk --first-parent
516
517           In a laundered branch, the delta queue is at the top.
518
519       History of the packaging, excluding the delta queue:
520
521           % gitk :/debian :!/debian/patches
522
523       Just the delta queue (i.e. Debian's changes to upstream):
524
525           % gitk --first-parent -- :/ :!/debian
526
527       Full history including old versions of the delta queue:
528
529           % gitk --date-order
530
531           The "Declare fast forward" commits you see have an older history
532           (usually, an older delta queue) as one parent, and a newer history
533           as the other.  --date-order makes gitk show the delta queues in the
534           right order.
535
536       Complete diff since the last upload:
537
538           % git diff dgit/dgit/sid..HEAD -- :/ :!/debian/patches
539
540           This includes changes to upstream files.
541
542       Interdiff of delta queue since last upload, if you really want it:
543
544           % git debrebase make-patches
545           % git diff dgit/dgit/sid..HEAD -- debian/patches
546
547       And of course there is:
548
549           % git debrebase status
550
551   Alternative ways to start a debrebase
552       Above we started an interactive debrebase by invoking git-debrebase(1)
553       like this:
554
555           % git debrebase -i
556
557       It is also possible to perform a non-interactive rebase, like this:
558
559           % git debrebase -- [git-rebase options...]
560
561       A third alternative is to have git-debrebase(1) shuffle all the Debian
562       changes to the end of your branch, and then manipulate them yourself
563       using git-rebase(1) directly.  For example,
564
565           % git debrebase
566           % git rebase -i HEAD~5      # there are 4 Debian patches
567
568       If you take this approach, you should be very careful not to start the
569       rebase too early, including before the most recent pseudomerge.  git-
570       rebase without a base argument will often start the rebase too early,
571       and should be avoided.  Run git-debrebase instead.  See also "ILLEGAL
572       OPERATIONS" in git-debrebase(5).
573

SEE ALSO

575       dgit(1), dgit(7), git-debrebase(1), git-debrebase(5)
576

AUTHOR

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.
581
582
583
584perl v5.32.1                    Debian Project         dgit-maint-debrebase(7)
Impressum