First, see my previous post and set up pbuilder using the .pbuilderrc there. Now, add the following lines to the bottom of that file.

# use previously built packages as local respository
BINDMOUNTS="$BUILDRESULT"
OTHERMIRROR="deb file:$BUILDRESULT ./"

# create local repository if it doesn't already exist,
# such as during initial 'pbuilder create'
if [ ! -d $BUILDRESULT ] ; then
        mkdir -p $BUILDRESULT
        # set permissions so I can delete files
        chgrp admin $BUILDRESULT
        chmod g+rwx $BUILDRESULT
fi
if [ ! -e $BUILDRESULT/Packages ] ; then
        touch $BUILDRESULT/Packages
fi
if [ ! -e $BUILDRESULT/Release ] ; then
        cat << EOF > $BUILDRESULT/Release
Archive: $DIST
Component: main
Origin: pbuilder
Label: pbuilder
Architecture: $ARCH
EOF

fi

These additions will cause pbuilder to add a new apt repository to each newly pbuilder base image, bind that repository into the chroot filesystem of the pbuilder environment, and create the initial apt files necessary for a basic local apt repository. This repository will be your normal result directory, where pbuilder puts completed .deb files after building, such as /var/cache/pbuilder/hardy-amd64/result/.

I also find it convenient for my user to be able to delete files from /var/cache/pbuilder/hardy-amd64/result/ without sudo, so the above script adds write permission for the “admin” group (which you probably are, if you have sudo access) to that directory.

Any new pbuilder base images made with sudo pbuilder create will use the new settings above. However, if you’ve previously created an image you’ll need to update it before proceeding.

sudo pbuilder update --override-config

Now, we need to update the /var/cache/pbuilder/hardy-amd64/result/Packages file every time we build a package. For this, we need to use a hook script. Create a script in $HOME/.pbuilder-hooks called D10apt-ftparchive, and make it executable.

touch $HOME/.pbuilder-hooks/D10apt-ftparchive
chmod a+x $HOME/.pbuilder-hooks/D10apt-ftparchive

The script should contain:

#!/bin/bash
# 2009-04-09 tyler - use previously built packages as an apt source
# http://blog.edseek.com/~jasonb/articles/pbuilder_backports/pbuilderbuild.html#pbuilderhook

echo Calling $0

: ${DIST:=$(lsb_release --short --codename)}
: ${ARCH:=$(dpkg --print-architecture)}
NAME="$DIST-$ARCH"
BUILDRESULT="/var/cache/pbuilder/$NAME/result/"

# create apt archive of previously built packages
( cd $BUILDRESULT ; apt-ftparchive packages . > $BUILDRESULT/Packages )

# see ~/.pbuilderrc for creation of $BUILDRESULT/Release

apt-get update

Now each time we call sudo pbuilder build package.dsc, pbuilder will first update /var/cache/pbuilder/hardy-amd64/result/Packages with the contents of whatever packages are already there.

As an added bonus, this allows you to satisfy build-dependencies that may be provided by hardy-backports or hardy-updates (but which aren’t in plain hardy, which is all that pbuilder uses). For instance, “debhelper >= 7″ is often required for packages in intrepid or jaunty. Stock hardy only offers debhelper 6, but hardy-backports contains debhelper 7. So just download that .deb file, copy it to /var/cache/pbuilder/hardy-amd64/result/, and build your package.

pbuilder will display a warning message when using packages in your local repository, but will build anyway.

WARNING: untrusted versions of the following packages will be installed!

Untrusted packages could compromise your system's security.
You should only proceed with the installation if you are certain that
this is what you want to do.

  debhelper

*** WARNING ***   Ignoring these trust violations because
                  aptitude::CmdLine::Ignore-Trust-Violations is 'true'!

You can now build packages and meet dependencies from your local archive.

I run Ubuntu 8.04 “hardy” on my servers. Hardy is almost a year old now, and although it has up to date security fixes it no longer has the latest releases of software. This is fine for most purpose, but sometimes I want an updated version of some software and I’m willing to risk the slight chance that it has bugs.

The best traceroute tool around is mtr. The version in Hardy is 0.72, but Jaunty now has a package for 0.75. So let’s backport it with pbuilder.

pbuilder is by far the easiest way to backport existing packages to older releases. The Ubuntu wiki provides an excellent pbuilder HowTo. If you want to know more about Debian packages, I also advise you to read the Ubuntu Packaging Guide.

Install pbuilder:

apt-get install pbuilder

Now configure it to support multiple distributions. This means you can build packages for Dapper, Hardy, Debian Lenny, whatever; and you can build i386 packages on amd64. Here is my ~/.pbuilderrc:

# 2008-08-13 tyler
# support building multiple distributions and architectures

: ${DIST:=$(lsb_release --short --codename)}
: ${ARCH:=$(dpkg --print-architecture)}
NAME="$DIST-$ARCH"
DISTRIBUTION="$DIST"
DEBOOTSTRAPOPTS=("--arch" "$ARCH" "${DEBOOTSTRAPOPTS[@]}")
BASETGZ="`dirname $BASETGZ`/$NAME-base.tgz"
BUILDRESULT="/var/cache/pbuilder/$NAME/result/"
APTCACHE="/var/cache/pbuilder/$NAME/aptcache/"
# Don't rebuild source files (.diff.gz, .dsc), or list them in .changes
# See Ubuntu bug 118181
DEBBUILDOPTS="-b"

case "$DIST" in
    karmic|jaunty|intrepid|hardy|dapper) # ubuntu specific
        MIRRORSITE="http://archive.ubuntu.com/ubuntu/"
        COMPONENTS="main restricted universe multiverse"
        ;;
    sid|squeeze|lenny|etch) # debian specific
        MIRRORSITE="http://mirrors.kernel.org/debian/"
        COMPONENTS="main contrib non-free"
        ;;
    *)
        echo "Unknown distribution: $DIST"
        exit 1
        ;;
esac

HOOKDIR=$HOME/.pbuilder-hooks

Now create your initial pbuilder root images. This will create a .tar.gz of a basic root image of that distribution, which pbuilder unpacks each time it builds packages. Do this once for each distribution and architecture for which you want to build. You select these with the DIST and ARCH environment variables.

The following builds environments for Hardy on amd64 and i386, and dapper on i386.

sudo DIST=hardy ARCH=amd64 pbuilder create
sudo DIST=hardy ARCH=i386 pbuilder create
sudo DIST=dapper ARCH=i386 pbuilder create

I run Hardy amd64 on my laptop, so I can run the first command without specifying DIST or ARCH.

sudo pbuilder create

You only need do the above once for each distribution/architecture combination you intend to support. You do not need to do it each time you build packages.

We are now ready to build mtr packages. Check the Ubuntu package archives for mtr. Note the updated mtr version for Jaunty.

Load the Jaunty mtr page, and look on the left side of the page where is says “Download Source Package mtr”. Download the three files there, ending in .dsc, orig.tar.gz, and .diff.gz. Alternatively, right-click on the .dsc and “Copy Link Location”, and use the dget command (install the “devscripts” package:

dget http://archive.ubuntu.com/ubuntu/pool/main/m/mtr/mtr_0.75-2.dsc

This will download the three needed files to the current directory. We’re now ready to build mtr with pbuilder.

sudo pbuilder build mtr_0.75-2.dsc

Or for another distribution and architecture:

sudo DIST=dapper ARCH=i386 pbuilder build mtr_0.75-2.dsc

pbuilder will now unpack the base tarball it created in /var/cache/pbuilder/hardy-amd64-base.tgz, download any packages mtr needs, and compile it, and create the .deb files. Here is my pbuilder mtr build log.

Results will be copied to /var/cache/pbuilder/DIST-ARCH/result.

tyler@baal:~$ ls /var/cache/pbuilder/hardy-amd64/result/
mtr_0.75-2_amd64.changes
mtr_0.75-2_amd64.deb
mtr_0.75-2.diff.gz
mtr_0.75-2.dsc
mtr_0.75.orig.tar.gz
mtr-tiny_0.75-2_amd64.deb

Now install .deb file, and you’re done!

mtr 0.75 for Ubuntu Hardy is now in the repository.