dgit-maint-debrebase - Man Page

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

    % 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 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 salsa.debian.org in addition to dgit-repos, you can do something like this:

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

Now go ahead and Debianise your package.  Make commits on the master branch, adding things in the debian/ directory, or patching the upstream source.  For technical reasons, it is essential that your first commit introduces the debian/ directory containing at least one file, and does nothing else. In other words, make a commit introducing debian/ before patching the upstream source.

Finally, you need an orig tarball:

    % git deborig

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)).

Comparing upstream's tarball releases

Using untagged upstream commits

    % git tag -s upstream/1.2.2+git20131211.ab34c21 ab34c21

    % git tag -s upstream/$(git show --date=format:%Y%m%d --pretty=format:"1.2.2+git%cd.%h" --quiet upstream/main) upstream/main

Because we want to work in git, we need a virtual upstream branch with virtual release tags.  gbp-import-orig(1) can manage this for us.  To begin

    % mkdir foo
    % cd foo
    % git init
    % git checkout -b upstream
    % gbp import-orig \
        --upstream-branch=upstream --debian-branch=master \
        --upstream-tag='upstream/%(version)s' \
        --sign-tags --no-pristine-tar \
        ../foo_1.2.2.orig.tar.xz
    % git branch -f upstream

This should leave you on the master branch.  Next, our upstream branch cannot be pushed to dgit-repos, but since we will need it whenever we import a new upstream version, we must push it somewhere.  The usual choice is salsa.debian.org:

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

You are now ready to proceed as above, making commits to the debian/ directory and to the upstream source.  As above, for technical reasons, it is essential that your first commit introduces the debian/ directory containing at least one file, and does nothing else.  In other words, make a commit introducing debian/ before patching the upstream source.

A convenient way to ensure this requirement is satisfied is to start by creating debian/gbp.conf:

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

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

    [import-orig]
    merge = False

and commit that:

    % git add debian/gbp.conf && git commit -m "create gbp.conf"

Note that we couldn't create debian/gbp.conf before now for the same technical reasons which require our first commit to introduce debian/ without patching the upstream source.  That's why we had to pass a lot of options to our first call to gbp-import-orig(1).

When upstream tags releases in git

    % git fetch --tags upstream

If you want to package an untagged upstream commit (because upstream does not tag releases or because you want to package an upstream development snapshot), see "Using untagged upstream commits" above.

When upstream releases only tarballs

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

Then, either

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

or if you have a working watch file

    % gbp import-orig --uscan

    % git debrebase new-upstream 1.2.3

This invocation of git-debrebase(1) involves a git rebase.  You may need to resolve conflicts if the Debian delta queue does not apply cleanly to the new upstream source.

If all went well, you can now review the merge of the new upstream release:

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

Also, diff with --name-status and --diff-filter=ADR to see just the list of added or removed files, which is useful 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. If you merged a git tag from upstream, you will first need to generate a tarball:

    % git deborig

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

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

    % git debrebase -i

to start an interactive rebase.  You can edit, re-order and delete commits just as you would during git rebase -i.

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, dgit push-source (or dgit push-built) 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 salsa.debian.org,

    % git debrebase conclude

Note that each time you conclude 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 editing session in a single debrebase, so that there is a single debrebase stitch.

Here we explain how to handle material that is merely DFSG-non-free. 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

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.  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 checkout -b upstream-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

Now either proceed with "Importing the release" on the 1.2.3+dfsg tag, or in the case of a new package,

    % git branch --unset-upstream
    % git reset --hard 1.2.3+dfsg

and proceed with "Initial Debianisation".

For subsequent releases (whether or not they require additional filtering):

    % 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" # if needed
    % git tag -s 1.2.4+dfsg
    % git checkout master
    % # proceed with "Importing the release" on 1.2.4+dfsg tag

Our upstream-dfsg branch cannot be pushed to dgit-repos, but since we will need it whenever we import a new upstream version, we must push it somewhere.  Assuming that you have already set up an origin remote per the above,

    % git push --follow-tags -u origin master upstream-dfsg

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

    % git rebase dgit/dgit/sid

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 can be used to strip both the patch and the reversion from the delta queue.

If you cannot rebase because you have already pushed to salsa.debian.org, say, you can manually apply the NMU debdiff, commit and debrebase.  The next dgit push will require --trust-changelog.

Above we noted that each time you conclude a debrebase, you introduce a pseudomerge into your git history, which may make it harder to read.

A simple convention you can use to minimise the number of pseudomerges is to git debrebase conclude only right before you upload or push to salsa.debian.org.

It is possible, though much less convenient, to reduce the number of pseudomerges yet further.  We debrebase only (i) when importing a new release, and (ii) right before uploading.  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 push and pull to and from salsa.debian.org during this.  Just before uploading, you debrebase, once, to tidy everything up.

In this workflow, debian/patches is purely an output of git-debrebase(1).  You should not make changes there.  They will either cause trouble, or be ignored and overwritten by git-debrebase(1).

debian/patches will often be out-of-date because git-debrebase(1) will only regenerate it when it needs to.  So you should not rely on the information in that directory.  When preparing patches to forward upstream, you should use git-format-patch(1) on git commits, rather than sending files from debian/patches.

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.  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. remotes/upstream/master.

If this is the first ever dgit push of the package, consider passing --deliberately-not-fast-forward instead of --trust-changelog.  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.)

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:

    % gitk --first-parent

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:

    % gitk --date-order

Complete diff since the last upload:

    % git diff dgit/dgit/sid..HEAD -- :/ :!/debian/patches

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

Above we started an interactive debrebase by invoking git-debrebase(1) like this:

    % git debrebase -i

It is also possible to perform a non-interactive rebase, like this:

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

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) directly.  For example,

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

If you take this approach, you should be very careful not to start the 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).