path: root/dgit-user.7.pod
diff options
authorIan Jackson <>2016-10-26 18:19:26 +0100
committerIan Jackson <>2016-10-30 17:13:25 +0000
commita940f4daeaac4af029412a8836e8153b67044a94 (patch)
tree67bf08d84b2b890faf9d9f22cb09b53f3cac5f2c /dgit-user.7.pod
parent859688c26baf58fcc6a61a5bbead9339b0b818f2 (diff)
dgit-user(7): More work in progress
Signed-off-by: Ian Jackson <>
Diffstat (limited to 'dgit-user.7.pod')
1 files changed, 152 insertions, 312 deletions
diff --git a/dgit-user.7.pod b/dgit-user.7.pod
index 1b12573..54bfa1d 100644
--- a/dgit-user.7.pod
+++ b/dgit-user.7.pod
@@ -4,384 +4,224 @@ dgit - tutorial for users of Debian-derived distros supported by dgit
-dgit lets you get the source code to every package on your system as a
-git tree.
+dgit lets you fetch the source code to every package on your
+ as if your distro used git to maintain all of it.
-You can then edit it, build updated binary packages and install and
-run them. You can also share your work with others.
+You can then edit it,
+build updated binary packages
+and install and run them.
+You can also share your work with others.
-This tutorial assumes you have basic familiarity with git. It does
-not assume any initial familiarity with Debian's packaging processes.
+This tutorial assumes you have basic familiarity with git.
+It does not assume any initial familiarity with
+ Debian's packaging processes.
-.head1 SUMMARY
+=head1 SUMMARY
=over 4
-% dgit clone glibc jessie
-% cd glibc
-% wget ';mbox=yes;msg=89' | patch -p1 -u
-Maintaining convenient and powerful git workflows takes priority over
-the usefulness of the raw Debian source package. The Debian archive
-is thought of as an output format.
-For example, we don't spend time curating a series of quilt patches.
-However, the information such a series would contain is readily
-available from B<dgit-repos>.
-It is more important to have the Debian package's git history be a
-descendent of upstream's git history than to use exactly the orig.tar
-that upstream makes available for download.
-Add the following to your ~/.gitconfig to teach git-archive(1) how to
-compress orig tarballs:
-=over 4
- [tar "tar.xz"]
- command = xz -c
- [tar "tar.gz"]
- command = gzip -c
-=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
-The final command detachs your master branch from the upstream remote,
-so that git doesn't try to push anything there, or merge unreleased
-upstream commits. If you want to maintain a copy of your packaging
-branch on B<> in addition to B<dgit-repos>, you can
-do something like this:
-=over 4
- % git remote add -f origin
- % git push --follow-tags -u origin master
-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, just make commits that change files
-outside of the I<debian/> directory. It is best to separate commits
-that touch I<debian/> from commits that touch upstream source, so that
-the latter can be cherry-picked by upstream.
-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 when
-forwarding patches (see FORWARDING PATCHES UPSTREAM, below).
-Finally, you need an orig tarball. Generate one with git-archive(1):
-=over 4
- % git archive -o ../foo_1.2.2.orig.tar.xz 1.2.2
-If you are using the version 1.0 source package format, replace 'xz'
-with 'gz'.
-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-archive(1).
-=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
-Now create I<debian/gbp.conf>:
-=over 4
- upstream-branch = upstream
- debian-branch = master
- upstream-tag = %(version)s
- sign-tags = True
- pristine-tar = False
- pristine-tar-commit = False
-Then we can import the upstream version:
-=over 4
- % git add debian/gbp.conf && git commit -m "create gbp.conf"
- % gbp import-orig ../foo_1.2.2.orig.tar.xz
-You are now ready to proceed as above, making commits to both the
-upstream source and the I<debian/> directory.
-If you want to maintain a copy of your repository on
-B<>, you should push both the origin and the upstream
-=over 4
- % git remote add -f origin
- % git push --follow-tags -u origin master upstream
+ % dgit clone glibc jessie
+ % cd glibc
+ % wget ';mbox=yes;msg=89' | patch -p1 -u
+ % git commit -a -m 'Fix libc lost output bug'
+ % gbp dch -S --since=dgit/dgit/sid --ignore-branch --commit
+ % sudo apt-get build-dep glibc
+ % dpkg-buildpackage -uc -b
+ % sudo dpkg -i ../libc6_*.deb
-=head2 debian/source/options
-We set some source package options such that dgit can transparently
-handle the "dropping" and "refreshing" of changes to the upstream
=over 4
- single-debian-patch
- auto-commit
+ % cd glibc
+ % dgit pull jessie
+ % gbp dch -S --since=dgit/dgit/sid --ignore-branch --commit
+ % dpkg-buildpackage -uc -b
+ % sudo dpkg -i ../libc6_*.deb
-You don't need to create this file if you are using the version 1.0
-source package format.
-=head2 Sample text for README.source
+dgit clone needs to be told the source package name
+(which might be different to the binary package name)
+and the codename of the Debian release
+(this is called the "suite").
-It is a good idea to explain how a user can obtain a break down of the
-changes to the upstream source:
+=head2 Finding the source package name
-=over 4
-The Debian packaging of foo is maintained using dgit. For the sake of
-an efficient workflow, Debian modifications to the upstream source are
-squashed into a single diff, rather than a series of quilt patches.
-To obtain a patch queue for package version 1.2.3-1:
+For many packages, the source package name is obvious.
+Otherwise, if you know a file that's in the package,
+you can look it up with dpkg:
=over 4
- # apt-get install dgit
- % dgit clone foo
- % cd foo
- % git log --oneline 1.2.3..debian/1.2.3-1 -- . ':!debian'
-See dgit(1), dgit(7) and dgit-maint-merge(7) for more information.
+ % dpkg -S /lib/i386-linux-gnu/
+ libc6:i386: /lib/i386-linux-gnu/
+ % dpkg -s libc6:i386
+ Package: libc6
+ Status: install ok installed
+ ...
+ Source: glibc
-Use B<dgit build>, B<dgit sbuild>, B<dgit build-source>, and B<dgit
-push> 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.
-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 When upstream tags releases in git
-It's a good idea to preview the merge of the new upstream release.
-First, just check for any new or deleted files that may need
-accounting for in your copyright file:
+(In this example,
+libc6 is a "multi-arch: allowed" package,
+ which means that it exists in several different builds
+ for different architectures.
+That's where C<:i386> comes from.)
-=over 4
- % git remote update
- % git diff --stat master..1.2.3 -- . ':!debian'
+=head2 Finding the Debian release (the "suite")
+Debian (and derived) distros normally refer to their releases by codenames.
+So for example, at the time of writing
+Debian C<jessie> (Debian 8) is Debian stable and
+the current version of Ubuntu is C<yakkety> (Yakkety Yak, 16.10).
-You can then review the full merge diff:
+If you don't know what you're running, try this:
=over 4
- % git merge-tree `git merge-base master 1.2.3` master 1.2.3 | $PAGER
+ % grep '^deb' /etc/apt/sources.list
+ deb jessie main non-free contrib
+ ...
+ %
-Once you're satisfied with what will be merged, update your package:
-=over 4
+=head2 What kind of source tree you get when you dgit clone
- % git archive ../foo_1.2.3.orig.tar.xz 1.2.3
- % git merge 1.2.3
- % dch -v1.2.3-1 New upstream release.
- % git add debian/changelog && git commit -m changelog
+If the Debian package is actually a version of an upstream release,
+the code layout should be like the upstream version.
+You should find that git commands C<git grep> work properly.
-and you are ready to try a build.
+The package's Debian metadata and the script for building binary
+packages are under C<debian/>.
+C<debian/control>, C<debian/changelog> and C<debian/rules> are the
+starting points.
+The Debian Policy Manual has most of the in-depth
+technical details.
-Again, if you are using the version 1.0 source package format, replace
-'xz' with 'gz'.
+For many Debian packages,
+there will also be some things in C<debian/patches/>.
+These will probably be in your git history
+(one way or another),
+and they are not used when building a package
+based on a git histroy obtained with dgit.
+It is best to ignore them.
-=head2 When upstream releases only tarballs
+=head2 What kind of history you get
+If you're lucky, the history will be a version of,
+or based on,
+the Debian maintainer's own git history,
+or upstream's git history.
-=over 4
+But for many packages the real git history
+does not exist or
+cannot be obtained in a standard form
+So yuu may find that the history is a rather short
+history invented by dgit.
- % gbp import-orig ../foo_1.2.2.orig.tar.xz
+dgit histories often contain automatically-generated commits,
+including commits which make no changes but just serve
+to make a rebasing branch fast-forward.
+If the package maintainer is using git then
+after dgit clone
+you may find that there is a useful C<vcs-git> remote
+referring to the Debian package maintainers repository
+for the pacakge.
+You can see what's there with C<git fetch vcs-git>.
+But use what you find there with care:
+Debian maintainers' git histories are often in
+formats which are very confusing and idiosyncratic
+from the point of view of those new to Debian git packaging.
-or if you have a working watch file
+=head1 BUILDING
-=over 4
+=head2 Always commit first
- % gbp import-orig --uscan
+When using git with some arbitrary Debian package
+you should normally commit before building.
+This is because Debian package builds are often quite messy:
+they may modify files which are also committed to git,
+or leave outputs and teporary files not covered by C<.gitignore>.
+Kf you always commit,
+you can use C<git reset --hard> and C<git clean -xdf>
+to put things back.
+But if you create a new file
+B<don't forget> to say C<git add>, and commit,
+as otherwise C<git clean> will delete your new file.
+=head2 Update the changelog (at least once)
-=head2 When upstream tags releases in git
+The binaries you build will have a version number which ultimately
+comes from the C<debian/changelog>. You want to be able to tell your
+binaries apart from your distro's.
-We create a DFSG-clean tag to merge to master:
+So you should update C<debian/changelog>
+to add a new stanza at the top,
+for your build.
+An easy way to do this is this rune:
=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
+ % gbp dch -S --since=dgit/dgit/sid --ignore-branch --commit
-Before merging the new 1.2.3+dfsg tag to master, you should first
-determine whether it would be legally dangerous for the non-free
-material to be publicly accessible in the git history on
-If it would be dangerous, there is a big problem;
-in this case please consult your archive administrators
-(for Debian this is the dgit administrator
-and the ftpmasters
-=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).
+which adds a new entry with a new version number chosen in a
+reasonably sensible way, and commits the result to your git branch.
-The basic steps are:
-=over 4
-=item 1.
-Create a new branch based off upstream's master branch.
-=item 2.
-git-cherry-pick(1) commits from your master branch onto your new
-=item 3.
-Push the branch somewhere and ask upstream to merge it, or use
-git-format-patch(1) or git-request-pull(1).
+You can use C<dpkg -i> to install the
+.debs that came out of your package.
+If the dependencies aren't installed,
+you will get an error, which can usually be fixed with
+C<apt-get -f install>.
-For example (and it is only an example):
-=over 4
+The C<dgit/jessie> branch (or whatever) is a normal git branch.
+You can use C<git push> to any suitable git server.
- % # fork foo.git on GitHub
- % git remote add -f fork
- % git checkout -b fix-error upstream/master
- % git config branch.fix-error.pushRemote fork
- % git cherry-pick master^2
- % git push
- % # submit pull request on GitHub
+If you want to contribute your changes back to Debian,
+you should probably send them as attachments to
+an email to the
+L<Debian Bug System|>
+(either a followup to an existing bug, or a new bug).
+Patches in C<<git-format-patch> format are usually very welcome.
+Anyone who gets that git branch from you
+will be able to build binary packages
+just as you did.
-Note that when you merge an upstream release containing your forwarded
-patches, git and dgit will transparently handle "dropping" the patches
-that have been forwarded, "retaining" the ones that haven't.
+However, the
+git branch is not sufficient to build a I<source package>.
+Source packages are somewhat awkward to work with.
+Indeed many plausible git histories or git trees
+cannot be converted into a suitable source package.
+So I recommend you share your git branch instead.
+If you need to provide a source package,
+you will probably want to read one of the other tutorials,
+such as L<dgit-nmu-simple(7)>, L<dgit-sponsorship(7)> or
+ L<dgit-maint-*(7)>
+multi-arch clash problem
-=over 4
- % dgit pull
-Alternatively, you can apply the NMU diff to your repository. The
-next push will then require I<--overwrite>.
=head1 SEE ALSO