[Date Prev][Date Next] [Thread Prev][Thread Next] [Date Index] [Thread Index]

Bits from the experimental autobuilder team (or: For Those Who Care About Experimental...)

Hello World,

As many of you undoubtedly know, experimental is autobuilt these days.
Experimental is a bit of a special case in Debian's distributions,
which means that our experimental autobuilders act slightly differently
from those of unstable, stable-security, and others. Since some of those
differences are visible and important for package maintainers who are
uploading packages to the experimental distribution (that'd be you!),
here's some background information on how it all currently works.

First, before anything else, it should be understood that experimental
is built on a 'best-effort' basis. If you upload to experimental, there
is no guarantee that we'll build your package within any given time on
any or all architectures, or indeed that we'll ever even manage to build
your package. This is a conscious decision: there might be a case where
the unstable buildd network for a given architecture can't keep up at
some time in the future, which might mean that we would want to
(temporarily or permanently) move some autobuilders from the
experimental autobuilder network to the unstable one; this might result
in a backlog for experimental. Also, most of the experimental
autobuilders also happen to autobuild for other distributions, like
sarge-volatile, where the configuration prioritizes those two over
experimental, for obvious reasons. This of course doesn't mean we won't
try to build as many packages from experimental as possible; but that,
of course, is a totally different matter.

What follows is a bit of a lengthy explanation of the why of a guideline
we're going to give maintainers who want to upload to experimental; if
you're not interested in that and/or are short on time, it's safe to
skip ahead to the final three paragraphs.


As I said above, experimental is a bit of a special case; the reason I
said that is that, even if you add an URI for experimental to your
sources.list and do not use apt pinning, packages from experimental are
not installed by default if there is also a package from unstable
available. This is a good thing; experimental packages are somethong one
should use consciously, after carefully considering the consequences --
not by trying it out and then discovering that your system is breaking
down. Thus, when apt (or any of its frontends, like aptitude) is given a
command to install a package without a version number or a distribution
specified, will install the safe choice.

We've decided to not use apt pinning to override this for
build-dependencies, but to instead use packages from unstable rather
than experimental unless versioned build-dependencies tell us otherwise.
After all, if the glibc maintainers upload glibc to experimental some
day to try out some new gizmo, you don't want to have to install that
one just to try out something completely unrelated to glibc which just
happens to be in experimental.

This was not initially possible with the buildd suite, since sbuild, the
component that does the build-dependency resolving and the actual
building, checks versions only after installing dependencies. However,
buildd is free software, so we've gone ahead and patched it on our
autobuilders to verify that any packages installed are of the right
version _before_ going ahead and installing them, modifying the apt
command line to include the version number if required (which only works
if there actually is a package of the given version available -- but
that shouldn't matter for now). With this patch, apt tries to install
"package=version" rather than just "package" for packages where that is
needed. As such, packages from experimental that have a versioned
build-depends on other packages in experimental will build on our

However, it will only work if the build-dependencies are fully
specified; i.e., if a package 'foo' in experimental requires another
package in experimental (let's call that one 'bar'), and another package
needs 'foo' from experimental to build, then just installing 'foo' from
experimental isn't going to cut it; you would end up with a command line
like "apt-get install foo=<experimental version>", which would try to
install the experimental version of foo with the unstable version of
bar, and fail because of unmet versioned dependencies.

The solution[1] to this problem lies in a different use of the
build-depends field: we're hereby asking maintainers who upload to
experimental, to make sure to fully specify their build-dependencies on
experimental packages; not just the packages they directly depend on,
but also the packages they indirectly, through other packages, depend

Let me repeat that, because it's quite important: if you upload a
package to experimental, and you declare a versioned build-depends on
something that is also in experimental, then you *must* make sure that
you also declare a versioned build-depends on any other packages from
experimental that your direct build-dependencies depend on; otherwise,
your package *will not build*.

It is, of course, not necessary to also declare versioned build-depends
on indirectly-required packages from unstable.

There, that was it. Thanks for your attention, and now please start
using experimental for experimental packages!

[1] It might be possible to write an apt preferences file to fix this
    problem differently, but not doing that actually has its advantages,
    in that we force maintainers to actually know what experimental
    package versions they're build-depending on.

Fun will now commence
  -- Seven Of Nine, "Ashes to Ashes", stardate 53679.4

Attachment: signature.asc
Description: Digital signature

Reply to: