Provided by: sbuild_0.62.6-1ubuntu2_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]
       [-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-deps=purge-mode]
       [--purge-session=purge-mode]  [-b|--batch] [-n|--nolog] [--run-lintian]
       [--lintian-opt=options]    [--lintian-opts=options]    [--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.

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

       -C, --check-depends-algorithm=algorithm
              Selects the algorithm  to  check  for  build  dependencies.  The
              default  algorithm ('first-only') just checks the first package,
              even if there are alternative dependencies available. The second
              algorithm  ('alternatives')  also  tries  to  satisfy  the build
              dependencies using these alternatives.

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

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

       --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  internal  (deprecated).   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 internal resolver  is  much
              older,  contains  several  significant  deficiencies such as not
              being  able  to   handle   complex   alternative   and   virtual
              dependencies,  and  is  deprecated.   Like apt, it only uses the
              first alternative build dependency  when  multiple  alternatives
              exist.   It  is  not  recommended  for  future  use, and will be
              removed in the future.

       --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  internal  and  apt
              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:

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

       o      Install the dummy dependency package into the local archive,

       o      Generate the Packages, Sources and Release files.

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

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

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

       o      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 (C) 1998-2000 Roman Hodek <roman@hodek.net>
       Copyright (C) 1998-1999 James Troup <troup@debian.org>
       Copyright (C) 2003-2006 Ryan Murray <rmurray@debian.org>
       Copyright (C) 2001-2003 Rick Younie <younie@debian.org>
       Copyright (C) 2003-2004 Francesco Paolo Lovergine <frankie@debian.org>
       Copyright (C) 2005      Michael Banck <mbanck@debian.org>
       Copyright (C) 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-stats(1),
       sbuild-unhold(1), sbuild-update(1), sbuild-upgrade(1), schroot(1),