summaryrefslogtreecommitdiff
path: root/dgit-maint-debrebase.7.pod
blob: f46944fe53cb646ef3b68a059e0f1ea23884b5f5 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
=head1 NAME

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

=head1 INTRODUCTION

This document describes elements of a workflow for maintaining a
non-native Debian package using B<dgit>.  We maintain the Debian delta
as a series of git commits on our master branch.  We use
git-debrebase(1) to shuffle our branch such that this series of git
commits appears at the end of the branch.  All the public git history
is fast-forwarding, i.e., we do not rewrite and force-push.

Some advantages of this workflow:

=over 4

=item

Manipulate the delta queue using the full power of git-rebase(1),
instead of relying on quilt(1), and without having to switch back and
forth between patches-applied and patches-unapplied branches when
committing changes and trying to build, as with gbp-pq(1).

=item

If you are using 3.0 (quilt), provide your delta queue as a properly
separated series of quilt patches in the source package that you
upload to the archive (unlike with dgit-maint-merge(7)).

=item

Avoid the git tree being dirtied by the application or unapplication
of patches, as they are always applied.

=item

Benefit from dgit's safety catches.  In particular, ensure that your
upload always matches exactly your git HEAD.

=item

Provide your full git history in a standard format on B<dgit-repos>,
where it can benefit downstream dgit users, such as people using dgit
to do an NMU (see dgit-nmu-simple(7) and dgit-user(7)).

=item

Minimise the amount you need to know about 3.0 (quilt) in order to
maintain Debian source packages which use that format.

=back

This workflow is appropriate for packages where the Debian delta
contains multiple pieces which interact, or which you don't expect to
be able to upstream soon.  For packages with simple and/or short-lived
Debian deltas, use of git-debrebase(1) might introduce unneeded
complexity (for examples, see "BEHAVIOUR TO AVOID" below).  For such
packages, consider the workflow described in dgit-maint-merge(7).

=head1 INITIAL DEBIANISATION

This section explains how to start using this workflow with a new
package.  It should be skipped when converting an existing package to
this workflow.

=head2 When upstream tags releases in git

Suppose that the latest stable upstream release is 1.2.2, and this has
been tagged '1.2.2' by upstream.

=over 4

    % git clone -oupstream https://some.upstream/foo.git
    % cd foo
    % git verify-tag 1.2.2
    % git reset --hard 1.2.2
    % git branch --unset-upstream

=back

The final command detaches your master branch from the upstream
remote, so that git doesn't try to push anything there, or merge
unreleased upstream commits.  To maintain a copy of your packaging
branch on B<salsa.debian.org> in addition to B<dgit-repos>, you can do
something like this:

=over 4

    % git remote add -f origin salsa.debian.org:Debian/foo.git
    % git push --follow-tags -u origin master

=back

Now go ahead and Debianise your package.  Just make commits on the
master branch, adding things in the I<debian/> directory.  If you need
to patch the upstream source, see "EDITING THE DELTA QUEUE", below.
Note that there is no need to maintain a separate 'upstream' branch,
unless you also happen to be involved in upstream development.  We
work with upstream tags rather than any branches, except temporary
branches used to prepare patches for forwarding upstream, for example.

Finally, you need an orig tarball:

=over 4

    % git deborig

=back

See git-deborig(1) if this fails.

This tarball is ephemeral and easily regenerated, so we don't commit
it anywhere (e.g. with tools like pristine-tar(1)).

=head3 Verifying upstream's tarball releases

=over 4

It can be a good idea to compare upstream's released tarballs with the
release tags, at least for the first upload of the package.  If they
are different, you might need to add some additional steps to your
I<debian/rules>, such as running autotools.

A convenient way to perform this check is to import the tarball as
described in the following section, using a different value for
'upstream-tag', and then use git-diff(1) to compare the imported
tarball to the release tag.  If they are the same, you can use
upstream's tarball instead of running git-deborig(1).

=back

=head2 When upstream releases only tarballs

We need a virtual upstream branch with virtual release tags.
gbp-import-orig(1) can manage this for us.  To begin

=over 4

    % mkdir foo
    % cd foo
    % git init

=back

Now create I<debian/gbp.conf>:

=over 4

    [DEFAULT]
    upstream-branch = upstream
    debian-branch = master
    upstream-tag = %(version)s

    sign-tags = True
    pristine-tar = False
    pristine-tar-commit = False

    [import-orig]
    merge-mode = merge

=back

gbp-import-orig(1) requires a pre-existing upstream branch:

=over 4

    % git add debian/gbp.conf && git commit -m "create gbp.conf"
    % git checkout --orphan upstream
    % git rm -rf .
    % git commit --allow-empty -m "initial, empty branch for upstream source"
    % git checkout -f master

=back

Then we can import the upstream version:

=over 4

    % gbp import-orig --merge-mode=replace ../foo_1.2.2.orig.tar.xz

=back

Our upstream branch cannot be pushed to B<dgit-repos>, but since we
will need it whenever we import a new upstream version, we must push
it somewhere.  The usual choice is B<salsa.debian.org>:

=over 4

    % git remote add -f origin salsa.debian.org:Debian/foo.git
    % git push --follow-tags -u origin master upstream

=back

You are now ready to proceed as above, making commits to the
I<debian/> directory.

=head1 CONVERTING AN EXISTING PACKAGE

This section explains how to convert an existing Debian package to
this workflow.  It should be skipped when debianising a new package.

=head2 No existing git history

=over 4

    % dgit clone foo
    % cd foo
    % git remote add -f upstream https://some.upstream/foo.git

=back

=head2 Existing git history using another workflow

First, if you don't already have the git history locally, clone it,
and obtain the corresponding orig.tar from the archive:

=over 4

    % git clone salsa.debian.org:Debian/foo
    % cd foo
    % origtargz

=back

If your tree is patches-unapplied, you will need to make a commit
corresponding to each of the quilt patches.  You can use

=over 4

    git debrebase convert-from-gbp

=back

or manually with gbp-pq(1):

=over 4

    % gbp pq import
    % gbp pq switch
    % git merge --ff-only patch-queue/master
    % gbp pq drop

=back

Then make new upstream tags available:

=over 4

    % git remote add -f upstream https://some.upstream/foo.git

=back

=for dgit-test dpkg-source-ignores begin

Now you simply need to ensure that your git HEAD is dgit-compatible,
i.e., it is exactly what you would get if you ran
B<dpkg-buildpackage -i'(?:^|/)\.git(?:/|$)' -I.git -S>
and then unpacked the resultant source package.

=for dgit-test dpkg-source-ignores end

To achieve this, you might need to delete
I<debian/source/local-options>.  One way to have dgit check your
progress is to run B<dgit build-source>.

The first dgit push will require I<--overwrite>.  If this is the first
ever dgit push of the package, consider passing
I<--deliberately-not-fast-forward> instead of I<--overwrite>.  This
avoids introducing a new origin commit into your git history.  (This
origin commit would represent the most recent non-dgit upload of the
package, but this should already be represented in your git history.)

=head1 IMPORTING NEW UPSTREAM RELEASES

=head2 Obtaining the release

=head3 When upstream tags releases in git

=over 4

    % git remote update

=back

=head3 When upstream releases only tarballs

You will need the I<debian/gbp.conf> from "When upstream releases only
tarballs", above.  You will also need your upstream branch.  Above, we
pushed this to B<salsa.debian.org>.  You will need to clone or fetch
from there, instead of relying on B<dgit clone>/B<dgit fetch> alone.

Then, either

=over 4

    % gbp import-orig --no-merge ../foo_1.2.3.orig.tar.xz

=back

or if you have a working watch file

=over 4

    % gbp import-orig --no-merge --uscan

=back

=head2 Importing the release

=over 4

    % git debrebase new-upstream-v0 1.2.3
    % dch -v1.2.3-1 New upstream release.
    % git add debian/changelog && git commit -m changelog

=back

You can now review the merge of the new upstream release:

=over 4

    git diff debian/1.2.2-1..HEAD -- . ':!debian'

=back

Pass I<--stat> just to see the list of changed files, which is useful
to determine whether there are any new or deleted files to may need
accounting for in your copyright file.

If you obtained a tarball from upstream, you are ready to try a build.
If you merged a git tag from upstream, you will first need to generate
a tarball:

=over 4

    % git deborig

=back

=head1 EDITING THE DELTA QUEUE

=head2 Adding new patches

Adding new patches is straightforward: just make commits touching only
files outside of the I<debian/> directory.  You can also use tools
like git-revert(1), git-am(1) and git-cherrypick(1).

=head2 Editing patches: starting a debrebase

git-debrebase(1) is a wrapper around git-rebase(1) which allows us to
edit, re-order and delete patches.  Run

=over 4

    % git debrebase

=back

to start an interactive rebase.  You can edit, re-order and delete
commits just as you would during B<git rebase -i>.  Alternatively, you
can perform a non-interactive rebase like this:

=over 4

    % git debrebase -- [git-rebase options...]

=back

A third alternative is to have git-debrebase(1) shuffle all the Debian
changes to the end of your branch, and then manipulate them yourself
using git-rebase(1).  For example,

=over 4

    % git debrebase launder
    % git rebase -i HEAD~5      # there are 4 Debian patches

=back

If you take this approach, you should be very careful not to start the
rebase earlier than the beginning of the delta queue.

=head2 Editing patches: finishing a debrebase

After completing the git rebase, your branch will not be a
fast-forward of the git HEAD you had before the rebase.  This means
that we cannot push the branch anywhere.  If you are ready to upload,
B<dgit push> or B<dgit push-source> will take care of fixing this up
for you.

If you are not yet ready to upload, and want to push your branch to a
git remote such as B<salsa.debian.org>,

=over 4

    % git debrebase launder
    % git debrebase stitch

=back

Note that each time you stitch a debrebase you introduce a pseudomerge
into your git history, which may make it harder to read.  Try to do
all of the editing of the delta queue that you think will be needed
for this upload in a single debrebase, so that there is a single
debrebase stitch.

A strategy is to debrebase only right before you upload.  Before that
point, instead of editing the existing delta queue, you append fixup
commits (and reversions of commits) that alter the upstream source to
the required state.  You can freely push and pull from
B<salsa.debian.org> during this.  Just before uploading, you debrebase
to tidy everything up.

=head1 BUILDING AND UPLOADING

Use B<dgit build>, B<dgit sbuild>, B<dgit push> and B<dgit
push-source> as detailed in dgit(1).  If any command fails, dgit will
provide a carefully-worded error message explaining what you should
do.  If it's not clear, file a bug against dgit.  Remember to pass
I<--new> for the first upload.

After dgit pushing, be sure to git push to B<salsa.debian.org>, if
you're using that.

As an alternative to B<dgit build> and friends, you can use a tool
like gitpkg(1).  This works because like dgit, gitpkg(1) enforces that
HEAD has exactly the contents of the source package.  gitpkg(1) is
highly configurable, and one dgit user reports using it to produce and
test multiple source packages, from different branches corresponding
to each of the current Debian suites.

If you want to skip dgit's checks while iterating on a problem with
the package build (for example, you don't want to commit your changes
to git), you can just run dpkg-buildpackage(1) or debuild(1) instead.

=head2 Laundering the delta queue before uploading

Just before you B<dgit push> or B<dgit push-source>, you might want to
have git-debrebase(1) shuffle your branch such that the Debian delta
queue appears at the end:

=over 4

    % git debrebase launder
    % dgit push-source

=back

Note that this will introduce a new pseudomerge.

=head1 HANDLING DFSG-NON-FREE MATERIAL

This covers only DFSG-non-free material.  Material which is legally
dangerous (for example, files which are actually illegal) cannot be
handled this way.

If you encounter possibly-legally-dangerous material in the upstream
source code you should seek advice.  It is often best not to make a
fuss on a public mailing list (at least, not at first).  Instead,
email your archive administrators.  For Debian that is
 To: dgit-owner@debian.org, ftpmaster@ftp-master.debian.org

=head2 When upstream tags releases in git

We create a DFSG-clean tag to import to master:

=over 4

    % git checkout -b pre-dfsg 1.2.3
    % git rm evil.bin
    % git commit -m "upstream version 1.2.3 DFSG-cleaned"
    % git tag -s 1.2.3+dfsg
    % git checkout master
    % git branch -D pre-dfsg

=back

=head2 When upstream releases only tarballs

The easiest way to handle this is to add a B<Files-Excluded> field to
I<debian/copyright>, and a B<uversionmangle> setting in
I<debian/watch>.  See uscan(1).  Alternatively, see the I<--filter>
option detailed in gbp-import-orig(1).

=head1 INCORPORATING NMUS

=over 4

    % dgit pull

=back

If the NMUer added new commits modifying the upstream source, you will
probably want to debrebase before your next upload to tidy those up.

For example, the NMUer might have used git-revert(1) to unapply one of
your patches.  A debrebase will strip both the patch and the reversion
from the delta queue.

=head1 SEE ALSO

dgit(1), dgit(7)

=head1 AUTHOR

This tutorial was written and is maintained by Sean Whitton
<spwhitton@spwhitton.name>.  It contains contributions from other dgit
contributors too - see the dgit copyright file.