Differences between revisions 19 and 20
Revision 19 as of 2008-11-14 04:30:44
Size: 7471
Editor: ?AndresMejia
Comment: Include snippet from PbuilderHowto in Ubuntu wiki
Revision 20 as of 2008-11-14 04:33:59
Size: 7463
Editor: ?AndresMejia
Comment: Change experimental to unstable. This is the behavior for cdebootstrap anyway.
Deletions are marked like this. Additions are marked like this.
Line 29: Line 29:
This is workable through the --basetgz parameter of pbuilder. You can pbuilder create --basetgz /var/cache/pbuilder/experimental.tgz --distribution experimental (and so on) to create the base tarballs. When using pdebuild, use pdebuild -- --basetgz /var/cache/pbuilder/<dist>.tgz instead, depending on which distribution you want. It is probably useful to make the default one sid (create without --basetgz and pdebuild without --basetgz). This is workable through the --basetgz parameter of pbuilder. You can pbuilder create --basetgz /var/cache/pbuilder/unstable.tgz --distribution unstable (and so on) to create the base tarballs. When using pdebuild, use pdebuild -- --basetgz /var/cache/pbuilder/<dist>.tgz instead, depending on which distribution you want. It is probably useful to make the default one sid (create without --basetgz and pdebuild without --basetgz).

?TableOfContents(2)

How to include local packages in the build

This is needed when you have to build and upload both a library, then a package depending on it:

  1. Create a directory for your dependencies (say /path/to/the/dir/deps)
  2. Add this to your pbuilder configuration: (the configuration file is usually in /etc/pbuilderrc)
    OTHERMIRROR="deb file:///path/to/the/dir/deps ./"
    BINDMOUNTS="/path/to/the/dir/deps"
    HOOKDIR="/path/to/hook/dir"
    EXTRAPACKAGES="apt-utils"
  3. create your base.tgz or update with --override-config so pbuilder picks up the sources.list changes
  4. put a file like D05deps to your $HOOKDIR, make it executable and put this in there:
    (cd /path/to/the/dir/deps; apt-ftparchive packages . > Packages)
    apt-get update
  5. build the library
  6. copy the resulting debs into /path/to/the/dir/deps
  7. build the application

Next time you start with step 5 :-).

How to build for different distributions

This is workable through the --basetgz parameter of pbuilder. You can pbuilder create --basetgz /var/cache/pbuilder/unstable.tgz --distribution unstable (and so on) to create the base tarballs. When using pdebuild, use pdebuild -- --basetgz /var/cache/pbuilder/<dist>.tgz instead, depending on which distribution you want. It is probably useful to make the default one sid (create without --basetgz and pdebuild without --basetgz).

The following is taken from https://wiki.ubuntu.com/PbuilderHowto

The only thing required to use pbuilder with multiple distributions is an alternate location to store the gzipped tarball that contains the pbuilder environment. On the command line, this can be specified with the 'basetgz' option. However, it is tedious to specify the full path every time pbuilder is run, so it is convenient to place a snippet in ~/.pbuilderrc to automate this:

# Codenames for Debian suites according to their alias. Update these when
# needed.
UNSTABLE_CODENAME="sid"
TESTING_CODENAME="lenny"
STABLE_CODENAME="etch"

# List of Debian suites.
DEBIAN_SUITES=($UNSTABLE_CODENAME $TESTING_CODENAME $STABLE_CODENAME
    "unstable" "testing" "stable")

# List of Ubuntu suites. Update these when needed.
UBUNTU_SUITES=("jaunty" "intrepid" "hardy" "gutsy")

# Mirrors to use. Update these to your preferred mirror.
DEBIAN_MIRROR="ftp.us.debian.org"
UBUNTU_MIRROR="mirrors.kernel.org"

# Optionally use the changelog of a package to determine the suite to use if
# none set.
if [ -z "${DIST}" ] && [ -r "debian/changelog" ]; then
    DIST=$(dpkg-parsechangelog | awk '/^Distribution: / {print $2}')
    # Use the unstable suite for Debian experimental packages.
    if [ "${DIST}" == "experimental" ]; then
        DIST="unstable"
    fi
fi

# Optionally set a default distribution if none is used. Note that you can set
# your own default (i.e. ${DIST:="unstable"}).
: ${DIST:="$(lsb_release --short --codename)"}

# Optionally change Debian codenames in $DIST to their aliases.
case "$DIST" in
    $UNSTABLE_CODENAME)
        DIST="unstable"
        ;;
    $TESTING_CODENAME)
        DIST="testing"
        ;;
    $STABLE_CODENAME)
        DIST="stable"
        ;;
esac

# Optionally set the architecture to the host architecture if none set. Note
# that you can set your own default (i.e. ${ARCH:="i386"}).
: ${ARCH:="$(dpkg --print-architecture)"}

NAME="$DIST"
if [ -n "${ARCH}" ]; then
    NAME="$NAME-$ARCH"
    DEBOOTSTRAPOPTS=("--arch" "$ARCH" "${DEBOOTSTRAPOPTS[@]}")
fi
BASETGZ="/var/cache/pbuilder/$NAME-base.tgz"
DISTRIBUTION="$DIST"
BUILDRESULT="/var/cache/pbuilder/$NAME/result/"
APTCACHE="/var/cache/pbuilder/$NAME/aptcache/"
BUILDPLACE="/var/cache/pbuilder/build/"

if $(echo ${DEBIAN_SUITES[@]} | grep -q $DIST); then
    # Debian configuration
    MIRRORSITE="http://$DEBIAN_MIRROR/debian/"
    COMPONENTS="main contrib non-free"
elif $(echo ${UBUNTU_SUITES[@]} | grep -q $DIST); then
    # Ubuntu configuration
    MIRRORSITE="http://$UBUNTU_MIRROR/ubuntu/"
    COMPONENTS="main restricted universe multiverse"
else
    echo "Unknown distribution: $DIST"
    exit 1
fi

Now, if the user sets DIST to another distribution such as hardy when running pbuilder, the tarball location will be changed. The line that sets the DISTRIBUTION only takes effect during the creation of a new base tarball, or if the --override-config option is given, where it specifies the distribution to use for the new base tarball. Setting BUILDRESULT or APTCACHE is optional, but possibly helpful.

Note that there are some optional lines in this snippet that appear after comments that start with "Optionally". These lines can be commented out.

If ARCH is set to a different architecture when running pbuilder, pbuilder will be set to create an environment to build packages for the architecture specified in ARCH.

We can now create and use alternate tarballs, as in the following examples:

# Create a base environment for Ubuntu gutsy
sudo DIST=gutsy pbuilder create

# Create a base environment for Debian sid
sudo DIST=sid pbuilder create

# Create a base environment for Ubuntu gutsy under
# the i386 architecture
sudo DIST=gutsy ARCH=i386 pbuilder create

# Update a base environment for Ubuntu gutsy
sudo DIST=gutsy pbuilder update

# Build a package using Ubuntu gutsy as the base
# environment
DIST=gutsy pdebuild

# Build a package using Ubuntu gutsy as the base
# environment under the i386 architecture
DIST=gutsy ARCH=i386 pdebuild

?Anchor(gcc-snapshot)

How to use pbuilder to test build with gcc-snapshot

While there are several ways to achieve this, an easy way is to use a hook to remove the existing gcc symlinks and replace them with a wrapper which uses gcc-snapshot. The following hook will do this for gcc, g++ and gfortran (extend it as needed):

aptitude -R -y install gcc-snapshot
cat > /usr/local/bin/gcc-snapshot <<EOF
#!/bin/sh
LD_LIBRARY_PATH=/usr/lib/gcc-snapshot/lib:$LD_LIBRARY_PATH
PATH=/usr/lib/gcc-snapshot/bin:$PATH
gcc "\$@"
EOF
chmod 755 /usr/local/bin/gcc-snapshot
cat > /usr/local/bin/g++-snapshot <<EOF
#!/bin/sh
LD_LIBRARY_PATH=/usr/lib/gcc-snapshot/lib:$LD_LIBRARY_PATH
PATH=/usr/lib/gcc-snapshot/bin:$PATH
g++ "\$@"
EOF
chmod 755 /usr/local/bin/g++-snapshot
cat > /usr/local/bin/gfortran-snapshot <<EOF
#!/bin/sh
LD_LIBRARY_PATH=/usr/lib/gcc-snapshot/lib:$LD_LIBRARY_PATH
PATH=/usr/lib/gcc-snapshot/bin:$PATH
g++ "\$@"
EOF
chmod 755 /usr/local/bin/gfortran-snapshot
rm -f /usr/bin/gcc /usr/bin/g++ /usr/bin/gfortran
ln -s /usr/local/bin/gcc-snapshot /usr/bin/gcc
ln -s /usr/local/bin/g++-snapshot /usr/bin/g++
ln -s /usr/local/bin/gfortran-snapshot /usr/bin/gfortran
#/bin/bash < /dev/tty > /dev/tty

Then, ensure that the environment variable LD_LIBRARY_PATH is set to prefer the libraries belonging to gcc-snapshot by adding the following to your .pbuilderrc:

export LD_LIBRARY_PATH=/usr/lib/gcc-snapshot/lib:$LD_LIBRARY_PATH

Save the file as D20_gcc43 (or something) in your hook directory, and make it executable to use gcc 4.3. Of course, care has to be taken that the build system also uses the gcc, gfortran, g++ etc. found in /usr/bin; otherwise, some extra work needs to be done.

Also, remember to NEVER upload packages produced by gcc-snapshot! :)