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
+If you have an existing git history that you have pushed to an
+ordinary git server like B<salsa.debian.org>, we start with that. If
+you don't already have it locally, you'll need to clone it, and obtain
+the corresponding orig.tar from the archive:
+
+=over 4
+
+ % git clone salsa.debian.org:Debian/foo
+ % cd foo
+ % dgit setup-new-tree
+ % origtargz
+
+=back
+
+If you don't have any existing git history, or you have history only
+on the special B<dgit-repos> server, we start with B<dgit clone>:
=over 4
% dgit clone foo
% cd foo
+
+=back
+
+Then we make new upstream tags available:
+
+=over 4
+
% git remote add -f upstream https://some.upstream/foo.git
=back
-=head2 Existing git history using another workflow
+We now use a B<git debrebase convert-from-*> command to convert your
+existing history to the git-debrebase(5) data model. Which command
+you should use depends on some facts about your repository:
+
+=over 4
+
+=item (A) There is no delta queue.
-First, if you don't already have the git history locally, clone it,
-and obtain the corresponding orig.tar from the archive:
+If there do not exist any Debian patches, use
=over 4
- % git clone salsa.debian.org:Debian/foo
- % cd foo
- % origtargz
+ % git debrebase convert-from-gbp
=back
-If your tree is patches-unapplied, some conversion work is needed.
-You can use
+=item (B) There is a delta queue, and patches are unapplied.
+
+This is the standard git-buildpackage(1) workflow: there are Debian
+patches, but the upstream source is committed to git without those
+patches applied. Use
=over 4
- git debrebase convert-from-gbp
+ % git debrebase convert-from-gbp
=back
-Then make new upstream tags available:
+If you were not previously using dgit to upload your package (i.e. you
+were not using the workflow described in dgit-maint-gbp(7)), and you
+happen to have run B<dgit fetch sid> in this clone of the repository,
+you will need to pass I<--fdiverged> to this command.
+
+=item (C) There is a delta queue, and patches are applied.
+
+Use
=over 4
- % git remote add -f upstream https://some.upstream/foo.git
+ % git debrebase convert-from-dgit-view
=back
-Now you simply need to ensure that your git HEAD is dgit-compatible,
+=back
+
+Finally, you need to ensure that your git HEAD is dgit-compatible,
i.e., it is exactly what you would get if you deleted .git, invoked
B<dpkg-buildpackage -S>, and then unpacked the resultant source
package.
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>.
-
=head1 GIT CONFIGURATION
git-debrebase(1) does not yet support using B<git merge> to merge
=over 4
- % git debrebase new-upstream-v0 1.2.3
+ % git debrebase new-upstream 1.2.3
=back
=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
+to determine whether there are any new or deleted files that may need
accounting for in your copyright file.
If you obtained a tarball from upstream, you are ready to try a build.
=head1 BUILDING AND UPLOADING
You can use dpkg-buildpackage(1) for test builds. When you are ready
-to build for an upload, use B<dgit sbuild>.
+to build for an upload, use B<dgit sbuild>, B<dgit pbuilder> or B<dgit
+cowbuilder>.
Upload with B<dgit push> or B<dgit push-source>. Remember to pass
I<--new> if the package is new in the target suite.
+In some cases where you used B<git debrebase convert-from-gbp> since
+the last upload, it is not possible for dgit to make your history
+fast-forwarding from the history on B<dgit-repos>. In such cases you
+will have to pass I<--overwrite> to dgit. git-debrebase will normally
+tell you if this will be needed.
+
Right before uploading, if you did not just already do so, you might
want to have git-debrebase(1) shuffle your branch such that the Debian
delta queue appears right at the tip of the branch you will push:
Our approach is to maintain a DFSG-clean upstream branch, and create
tags on this branch for each release that we want to import. We then
-import those tags per "Importing the release", above.
+import those tags per "Importing the release", above. In the case of
+a new package, we base our initial Debianisation on our first
+DFSG-clean tag.
For the first upstream release that requires DFSG filtering:
% git commit -m "upstream version 1.2.3 DFSG-cleaned"
% git tag -s 1.2.3+dfsg
% git checkout master
- % # proceed with "Importing the release"
=back
-And for subsequent releases (whether or not they require filtering):
+Now either proceed with "Importing the release" on the 1.2.3+dfsg tag,
+or in the case of a new package,
+
+=over 4
+
+ % git branch --unset-upstream
+ % git reset --hard 1.2.3+dfsg
+
+=back
+
+and proceed with "INITIAL DEBIANISATION".
+
+For subsequent releases (whether or not they require additional
+filtering):
=over 4
% git checkout upstream-dfsg
% git merge 1.2.4
% git rm further-evil.bin # if needed
- % git commit -m "upstream version 1.2.4 DFSG-cleaned"
+ % git commit -m "upstream version 1.2.4 DFSG-cleaned" # if needed
% git tag -s 1.2.4+dfsg
% git checkout master
- % # proceed with "Importing the release"
+ % # proceed with "Importing the release" on 1.2.4+dfsg tag
=back
=back
-If that fails, because your branch and the NMUers work represent
+If that fails, because your branch and the NMUers' work represent
divergent branches of development, you have a number of options. Here
we describe the two simplest.
=head2 Upstream branches
-Except in the case where upstream releases only tarballs, or we
-require DFSG filtering, we do not 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).
+In this workflow, we specify upstream tags rather than any branches.
+
+Except when (i) upstream releases only tarballs, (ii) we require DFSG
+filtering, or (iii) you also happen to be involved in upstream
+development, we do not maintain any local branch corresponding to
+upstream, except temporary branches used to prepare patches for
+forwarding, and the like.
The idea here is that from Debian's point of view, upstream releases
-are immutable points in history, and so better represented by tags.
+are immutable points in history. We want to make sure that we are
+basing our Debian package on a properly identified upstream version,
+rather than some arbitrary commit on some branch. Tags are more
+useful for this.
+
+Upstream's branches remain available as the git remote tracking
+branches for your upstream remote, e.g. I<remotes/upstream/master>.
=head2 The first ever dgit push
origin commit would represent the most recent non-dgit upload of the
package, but this should already be represented in your git history.)
+=head2 Inspecting the history
+
+The git history made by git-debrebase can seem complicated.
+Here are some suggestions for helpful invocations of gitk and git.
+They can be adapted for other tools like tig(1), git-log(1), magit, etc.
+
+History of package in Debian, disregarding history from upstream:
+
+=over
+
+ % gitk --first-parent
+
+In a laundered branch, the delta queue is at the top.
+
+=back
+
+History of the packaging, excluding the delta queue:
+
+ % gitk :/debian :!/debian/patches
+
+Just the delta queue (i.e. Debian's changes to upstream):
+
+ % gitk --first-parent -- :/ :!/debian
+
+Full history including old versions of the delta queue:
+
+=over
+
+ % gitk --date-order
+
+The "Declare fast forward" commits you see have an older history
+(usually, an older delta queue) as one parent,
+and a newer history as the other.
+--date-order makes gitk show the delta queues in the right order.
+
+=back
+
+Complete diff since the last upload:
+
+=over
+
+ % git diff dgit/dgit/sid..HEAD -- :/ :!/debian/patches
+
+This includes changes to upstream files.
+
+=back
+
+Interdiff of delta queue since last upload, if you really want it:
+
+ % git debrebase make-patches
+ % git diff dgit/dgit/sid..HEAD -- debian/patches
+
+And of course there is:
+
+ % git debrebase status
+
=head2 Alternative ways to start a debrebase
Above we started an interactive debrebase by invoking git-debrebase(1)
=over 4
- % git debrebase launder
+ % git debrebase
% 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 too early.
+rebase too early,
+including before the most recent pseudomerge.
+git-rebase without a base argument will often
+start the rebase too early,
+and should be avoided.
+Run git-debrebase instead.
+See also "ILLEGAL OPERATIONS" in git-debrebase(5).
=head1 SEE ALSO
-dgit(1), dgit(7)
+dgit(1), dgit(7), git-debrebase(1), git-debrebase(5)
=head1 AUTHOR
~ianmdlvl / dgit.git / blobdiff