Provided by: sbuild_0.64.1-1ubuntu4_all bug

NAME

       sbuild - build debian packages from source

SYNOPSIS

       sbuild [-h|--help | -V|--version] [-v|--verbose | -q|--quiet] [-D|--debug] [-A|--arch-all]
       [--archive=archive]  [-d|--dist=distribution]  [-c|--chroot=chroot]  [--arch=architecture]
       [--build=architecture]     [--host=architecture]    [-s|--source]    [--force-orig-source]
       [--make-binNMU=changelog-entry]    [--binNMU=NMU-version]     [--append-to-version=string]
       [--add-depends=dependency]   [--add-conflicts=dependency]  [--add-depends-arch=dependency]
       [--add-conflicts-arch=dependency]         [--add-depends-indep=dependency]         [--add-
       conflicts-indep=dependency]      [-m|--maintainer=maintainer]     [-e|--uploader=uploader]
       [-k|--keyid=key-id] [-j|--jobs=n] [--debbuildopt=option] [--debbuildopts=options] [--dpkg-
       source-opt=options]          [--dpkg-source-opts=options]          [-p|--purge=purge-mode]
       [--purge-build=purge-mode]     [--purge-deps=purge-mode]      [--purge-session=purge-mode]
       [-b|--batch]   [-n|--nolog]   [--run-lintian]  [--no-run-lintian]  [--lintian-opt=options]
       [--lintian-opts=options]  [--run-piuparts]  [--no-run-piuparts]   [--piuparts-opt=options]
       [--piuparts-opts=options]   [--piuparts-root-arg=options]   [--piuparts-root-args=options]
       [--pre-build-commands=string]                             [--chroot-setup-commands=string]
       [--chroot-cleanup-commands=string]                          [--post-build-commands=string]
       [--log-external-command-output] [--log-external-command-error]  [--setup-hook=hook-script]
       [--build-dep-resolver=resolver]         [--resolve-alternatives|--no-resolve-alternatives]
       [PACKAGE[.dsc]]

DESCRIPTION

       sbuild rebuilds Debian binary packages from the corresponding  Debian  source,  installing
       any  missing  source  dependencies.   The  build  takes  place  in a dedicated clean build
       environment (chroot), rather than on the host system.

       sbuild can fetch the Debian source over  a  network,  or  it  can  use  locally  available
       sources.

       sbuild  is given a packages to process as the argument PACKAGE[.dsc].  This argument is in
       the form of either a debianized package source directory, a source package name along with
       a  version  in  the  form  package_version, or a .dsc file. If no arguments are given, the
       current working directory is passed as an argument.

       For arguments given as source directories, dpkg-source is first run to  produce  a  source
       .dsc  file.  Then, the package is built using the .dsc produced. For arguments in the form
       package_version, apt is used to download the source package. For arguments given as a .dsc
       file,  sbuild builds the source packages directly. For .dsc files in remote locations, the
       source packages are downloaded first, then built.

       It is also possible to run  external  commands  with  sbuild.  See  the  section  EXTERNAL
       COMMANDS for more on this.

       sbuild  mails  the  build  logs  to  a  user.  It is configured by the configuration files
       /etc/sbuild/sbuild.conf  and  ~/.sbuildrc.   An   example   sbuildrc   is   available   in
       /usr/share/doc/sbuild/examples/example.sbuildrc.

       You  can  build  either  using  a  local  package  with  its  .dsc file or a remote one by
       specifying an explicit dpkg version.

       Note: When using schroot (recommended), the chroot having  the  name  (or  alias)  of  the
       specified  distribution  will  be  used;  schroot uses a chroot named $distribution-$arch-
       sbuild, $distribution-sbuild, $distribution-$arch  or  $distribution,  in  that  order  of
       preference.  The -c or --chroot option may be used to override the chroot to be used. When
       configured to use sudo (deprecated), sbuild will look for a symlink to a chroot  with  the
       same  name as the distribution specified.  sbuild will use a symlink to the chroot located
       in  /etc/sbuild/chroot/$distribution,  or  must  be  run  in  a  directory  containing   a
       chroot-$distribution  symlink  to  the  chroot  (not  recommended,  but  done for backward
       compatibility).

OPTIONS

       -h, --help
              Display this manual.

       -V, --version
              Print version information.

       --add-depends=dependency

       --add-conflicts=dependency

       --add-depends-arch=dependency

       --add-conflicts-arch=dependency

       --add-depends-indep=dependency

       --add-conflicts-indep=dependency
              These options add a build dependencies  to  the  source  package  being  built,  in
              addition  to  the  build dependency information specified in debian/control.  These
              dependencies will be concatenated directly to the  Build-Depends,  Build-Conflicts,
              Build-Depends-Arch,  Build-Conflicts-Arch, Build-Depends-Indep and Build-Conflicts-
              Indep dependencies, respectively.  The options may be used any number of  times  to
              add  multiple  dependencies.   The  format  is  identical  to  the  format  used in
              debian/control.

       --arch=architecture
              Build using the architecture specified.  A chroot named  $distribution-$arch-sbuild
              or  $distribution-arch  is  searched  for, in that order of preference.  The chroot
              must be installed and configured appropriately to build as that architecture,  e.g.
              using  personality=linux32  to  build  i386 packages on an amd64 system.  Note that
              this option is equivalent to "--host=architecture --build=architecture".

       --host=architecture
              Build using the host architecture specified.  If $host and $build  don't  match,  a
              chroot  named  $distribution-$build-$host-sbuild  or  $distribution-$build-$host is
              searched for, falling back to $distribution-$host-sbuild or $distribution-$host, in
              that  order of preference.  This option is only useful for cross-building when used
              together with --build.

       --build=architecture
              Build using the build architecture specified.   This  option  is  only  useful  for
              cross-building  when  used  together with --host.  If --build is not specified, the
              default system architecture is assumed.

       -A, --arch-all
              Also build Architecture: all packages, i.e. use dpkg-buildpackage -b instead of -B.

       --no-arch-all
              Do not build Architecture: all packages, i.e. use dpkg-buildpackage -B  instead  of
              -b. This option is the opposite of --arch-all.

       -b, --batch
              Operate  in  batchmode, i.e. write a build-progress file during execution and files
              on shutdown to facilitate a clean restart.

       -c, --chroot=chroot
              Use  the  specified  chroot.  If  not  specified,  the  default  is  the  first  of
              $distribution-$arch-sbuild,     $distribution-sbuild,     $distribution-$arch    or
              $distribution that exists.

       -d, --dist=distribution
              Fetch source packages from specified distribution.

       --archive=archive
              Communicate with specified archive.

       -D, --debug
              Enable debug output.

       --apt-clean
       --no-apt-clean
              Run (or do not run) apt-get  clean  in  the  chroot  before  executing  the  build,
              overriding the default setting.

       --apt-update
       --no-apt-update
              Run  (or  do  not  run)  apt-get  update  in the chroot before executing the build,
              overriding the default setting.

       --apt-upgrade
       --no-apt-upgrade
              Run (or do not run) apt-get upgrade in  the  chroot  before  executing  the  build,
              overriding the default setting.

       --apt-distupgrade
       --no-apt-distupgrade
              Run  (or  do not run) apt-get distupgrade in the chroot before executing the build,
              overriding the default setting.

       -m, --maintainer=maintainer
              Specify the identity to use  for  GPG  signing  packages,  and  also  used  as  the
              maintainer for binary NMUs.  This does not normally require setting (it defaults to
              the uploader).

       -e, --uploader=uploader
              Passed to dpkg-genchanges and is used to set the Changed-by: field in the  .changes
              file(s).

       -k, --keyid=key-id
              Passed  to dpkg-genchanges and is used to set the key to sign the .changes file(s).
              Default is not using any key.

       -j, --jobs=n
              Number of jobs to run simultaneously.  Passed through to dpkg-buildpackage.

       --debbuildopt=option
              Pass the specified option directly to dpkg-buildpackage.

       --debbuildopts=options
              Pass the specified options directly to dpkg-buildpackage.  The  options  should  be
              separated by spaces.  If any options contain spaces, use --debbuildopt instead.

       --dpkg-source-opt=options
              Pass the specified options directly to dpkg-source. This is only used when creating
              a source package from a Debianized source directory.
              NOTE: The '-b' option will always be passed to dpkg-source.

       --dpkg-source-opts=options
              Extra options to be appended to existing options passed to dpkg-source.

       --mail-log-to=email-address
              Send the build log to the specified email  address.   This  overrides  the  $mailto
              configuration option.

       -n, --nolog
              Do  not  create a package log file in the $log_dir directory and no build log file,
              but print everything to stdout. Also do not send any log mails.

       -p, --purge=purge-mode
              Convenience option to set purge-mode for build directory,  build  dependencies  and
              session.

       --purge-build=purge-mode
              purge-mode  determines  if  the  build  directory  will  be  deleted after a build.
              Possible values are always (default), never, and successful.

       --purge-deps=purge-mode
              purge-mode determines if the build dependencies will  be  removed  after  a  build.
              Possible values are always (default), never, and successful.

       --purge-session=purge-mode
              Purge  the  schroot  session following a build.  This is useful in conjunction with
              the --purge-build and --purge-deps options when using snapshot  chroots,  since  by
              default the snapshot will be deleted.  Possible values are always (default), never,
              and successful.

       -s, --source
              Also build source package, i.e. use dpkg-buildpackage without -B.

       --no-source
              Don't build source package, i.e. use dpkg-buildpackage with -B.  This option is the
              opposite of --source.

       --force-orig-source
              When  used  with  in  conjunction  with -s, this option forces the inclusion of the
              orig.tar.gz file in the generated .changes file, even in cases where it  would  not
              normally be included, i.e. use dpkg-buildpackage -sa.

       --use-snapshot
              Installs the latest snapshot gcc compiler from the gcc-snapshot package, and alters
              the build environment to use the snapshot compiler for the build.

       -v, --verbose
              Be verbose, i.e. all information goes to stdout as well as to the log files.

       -q, --quiet
              Be quiet.  This is the opposite of --verbose.

       --make-binNMU=changelog-entry
              With this option, sbuild will create a new changelog entry in  debian/changelog  of
              every  package built. The version number will be in the format for binary-only NMUs
              (see --binNMU); the maintainer is set to the maintainer name configured for sbuild.
              changelog-entry  will  be  used  as the changelog entry following “Binary-only non-
              maintainer upload for ARCH -- no source changes”. Please note that the versions  in
              the  PACKAGE_VERSION[.dsc] arguments still have to be the unmodified (non-NMU ones)
              so that the sources can be found. The version number in log files and mails will be
              modified by sbuild automatically.

       --binNMU=NMU-version
              The  version  number  of  the  binary NMU.  This should be used in conjunction with
              --make-binNMU.  version is a single number for the (+bn)  format  used  for  binary
              NMUs.

       --append-to-version=string
              This  option  is similar to --make-binNMU except that it allows the user to specify
              an arbitrary string to be appended to the version number  (immediately  before  the
              '+' in the Debian revision if --make-binNMU is also provided).

       --run-lintian
              Run lintian after a successful build.

       --no-run-lintian
              Don't run lintian after a successful build.  If sbuild is configured to run lintian
              by default, this option will prevent lintian being run.

       --lintian-opt=options
              Run lintian with the specified options.

       --lintian-opts=options
              Append extra options to existing options passed to lintian.

       --run-piuparts
              Run piuparts after a successful build.

       --no-run-piuparts
              Don't run piuparts after a successful  build.   If  sbuild  is  configured  to  run
              piuparts by default, this option will prevent piuparts being run.

       --piuparts-opt=options
              Run piuparts with the specified options.

       --piuparts-opts=options
              Append extra options to existing options passed to piuparts.

       --piuparts-root-arg=options
              Add  an  argument  that  is  used  to  launch piuparts as root. If no arguments are
              specified, piuparts will be launched via sudo.

       --piuparts-root-args=options
              Add arguments that are used to  launch  piuparts  as  root.  If  no  arguments  are
              specified, piuparts will be launched via sudo.

       --pre-build-commands=string
              Run  this  command before a build starts. This option can be used multiple times to
              add multiple commands.

       --chroot-setup-commands=string
              Run these commands when a chroot is setup, before deps are installed.  This  option
              can be used multiple times to add multiple commands.

       --chroot-cleanup-commands=string
              Run  these  commands when a chroot is cleaned up, before build directory is purged.
              This option can be used multiple times to add multiple commands.

       --post-build-commands=string
              Run this command after a successful build. This option can be used  multiple  times
              to add multiple commands.

       --log-external-command-output
              Write output from external commands to the build log.

       --log-external-command-error
              Write error output from external commands to the build log.

       --setup-hook=hook-script DEPRECATED
              This  option is deprecated. Use of this option will add hook-script to the external
              commands to run via chroot-setup-commands.

       --build-dep-resolver=resolver
              Use the specified resolver to handle selecting the build  dependencies.   Supported
              resolvers  are  apt (the default), aptitude and xapt.  The apt resolver is the most
              appropriate resolver for most users, for building for unstable,  stable  and  other
              distributions.   If alternative build dependencies are used (excluding architecture
              restrictions), only the first alternative will be used; the others will be ignored.
              The aptitude resolver is very similar, but smarter and slower, and it will consider
              all alternatives by default; it is suited  to  more  complex  situations,  such  as
              building packages for the experimental distribution, where packages need installing
              from multiple suites (unstable and experimental).  Due  to  performance  and  other
              issues  (bug  #139615),  aptitude  is not recommended for use by default.  The xapt
              resolver is intended only for  cross-building,  and  is  a  temporary  transitional
              feature  which  will  be  removed following the complete introduction of multi-arch
              support.

       --resolve-alternatives
              Allow the use of  alternatives  in  Build-Depends,  Build-Depends-Arch  and  Build-
              Depends-Indep.  This is the default for the aptitude dependency resolver.

       --no-resolve-alternatives
              Do  not  allow  the  use  of  alternatives in Build-Depends, Build-Depends-Arch and
              Build-Depends-Indep.  Note that alternatives for the same package  (e.g.  different
              versions)  are  still allowed.  This is the default for the apt and xapt dependency
              resolvers.

EXTERNAL COMMANDS

       Support to run external commands during an sbuild run  is  provided.  A  set  of  external
       commands  can  be  run  at  various  stages  of a build. Providing commands to run is done
       through the appropriate options given on the command line  and  through  the  use  of  the
       configuration  files. In the configuration file, the list of commands to run are placed in
       a hash of arrays of arrays of strings corresponding to the commands to run.

       Here's an example of how to edit the configuration files  to  run  "foo"  and  "bar"  with
       arguments before a build starts.

       $external_commands = {
           "pre-build-commands" => [
               ['foo', 'arg1', 'arg2'],
               ['bar', 'arg1', 'arg2', 'arg3'],
           ],
       };

       Hash  keys  for  commands to run at other stages have the same name as their corresponding
       command-line option name without the preceding '--'.

       Here's an example of how to do the same  with  the  previous  example,  except  using  the
       --pre-build-commands option.

       $ sbuild \
             --pre-build-commands='foo arg1 arg2' \
             --pre-build-commands='bar arg1 arg2 arg3'

       Besides  running  external  commands,  sbuild  can  also detect the use of certain percent
       escapes given as arguments. These are used to allow for a command to be  supplied  with  a
       certain argument depending on the escape given.  For example, it could be possible to have
       an external command be given the path to a .changes file.

       Here is a listing of keywords and a description of what it's converted to.

       %%     Used to escape a '%'.

       %d, %SBUILD_DSC
              These escapes are converted to the absolute path to a package's .dsc file.

       %c, %SBUILD_CHANGES
              These escapes are converted to the absolute path to  a  package's  source  .changes
              file.

       Percent  escapes  are  only  substituted when an appropriate value is defined for them. At
       other times, it is left unchanged. For example, a .changes file is only defined at the end
       of a build, so using %c will only be substituted for post-build-commands.

       Here's an example of using an escape to run a program foo on a .changes file after a build
       is done.

       $ sbuild --post-build-commands \
             'foo %SBUILD_CHANGES'

       One final note, external commands are processed in the order they are  given.   Also,  the
       commands  given  in  a  configuration  file  are  processed first, then the commands given
       through the command line options.

LOCAL ARCHIVE

       The apt and aptitude resolvers create a local archive for installing  build  dependencies.
       This  is  an internal implementation detail of the build dependency resolver, which is not
       user configurable, and is indended to be entirely transparent  to  the  user.   The  local
       archive  exists  only  transiently  during  the package build.  It does not persist across
       builds, and it is only used to store the dummy dependency packages created  for  a  single
       build.

       The dependency resolvers do the following:

       ·      Create a dummy dependency package.  This contains the Build-Depends (and optionally
              Build-Depends-Arch and Build-Depends-Indep) as Depends,  and  Build-Conflicts  (and
              optionally Build-Conflicts-Arch and Build-Conflicts-Indep) as Conflicts.

       ·      Install the dummy dependency package into the local archive,

       ·      Generate the Packages, Sources and Release files.

       ·      Write a sources.list file for the local archive into /etc/apt/sources.list.d.

       ·      Inject  the  lists  directly into /var/lib/apt/lists.  This step is to save running
              updating all apt sources which is undesirable during a build; apt and  aptitude  do
              not support updating a single source at present.

       ·      Regenerate the apt caches to ensure everything is in sync.

       ·      Install  the  dummy  dependency  package with apt or aptitude; the dummy package is
              pulled from the local apt archive, while all its dependencies are pulled  from  the
              regular configured apt sources.

       At  the  end  of the build, the local archive is removed, along with the rest of the build
       tree.

ENVIRONMENT VARIABLES

       The following environment variables are used by sbuild:

       HOME   The home directory of the user.

       LOGNAME
              Used in lockfiles.

FILES

       /etc/sbuild/sbuild.conf
              Configuration, maintained by  the  system  administrator.   This  may  be  used  to
              override the defaults.

       /etc/sbuild/chroot
              Directory  containing symbolic links to chroots.  This is only used for sudo chroot
              access; schroot access uses the schroot chroot configuration.

       ~/.sbuildrc
              User-specific configuration.

       /var/lib/sbuild
              Build trees, archive signing keys, build statistics and lock files.

AUTHORS

       Roman Hodek <Roman.Hodek@informatik.uni-erlangen.de>.

       sbuild is based on debbuild, written  by  James  Troup  <james@nocrew.org>  and  has  been
       modified by
       Ben Collins <bcollins@debian.org>,
       Ryan Murray <rmurray@debian.org>,
       Francesco Paolo Lovergine <frankie@debian.org>,
       Michael Banck <mbanck@debian.org>, and
       Roger Leigh <rleigh@debian.org>

COPYRIGHT

       Copyright © 1998-2000 Roman Hodek <roman@hodek.net>
       Copyright © 1998-1999 James Troup <troup@debian.org>
       Copyright © 2003-2006 Ryan Murray <rmurray@debian.org>
       Copyright © 2001-2003 Rick Younie <younie@debian.org>
       Copyright © 2003-2004 Francesco Paolo Lovergine <frankie@debian.org>
       Copyright © 2005      Michael Banck <mbanck@debian.org>
       Copyright © 2005-2009 Roger Leigh <rleigh@debian.org>

SEE ALSO

       sbuild.conf(5),         sbuild-abort(1),         sbuild-adduser(8),         sbuild-apt(1),
       sbuild-checkpackages(1),  sbuild-createchroot(8),  sbuild-distupgrade(1),  sbuild-hold(1),
       sbuild-setup(7).   sbuild-shell(1), sbuild-unhold(1), sbuild-update(1), sbuild-upgrade(1),
       schroot(1),