Merge lp:~cjwatson/ubuntu-archive-publishing/add-germinate-scripts into lp:ubuntu-archive-publishing

[Colin Watson]

Add cron.germinate and its associated scripts and tests, split out from Launchpad.

As part of the work to instantiate a derived archive for the phone RTM project, William Grant suggested that we should split cron.germinate out of Launchpad proper and move it into ubuntu-archive-publishing, which in any case removes a large chunk of hardcoded Ubuntu-specific policy in Launchpad.

This is a fairly straight port of the relevant Launchpad code to run standalone. The main changes required were providing some minimal LaunchpadScript-like functionality, using launchpadlib rather than database access, and extensive surgery on generate-extra-overrides' test suite to create mock launchpadlib objects rather than using the test database. There are quite a number of remaining infelicities, especially in maintenance-check which has been on my refactoring list for quite a while, but they're essentially the same infelicities currently found in Launchpad.

This can only be deployed once https://rt.admin.canonical.com/Ticket/Display.html?id=72323 ("Please install python-launchpadlib on pepo and bilimbi") is complete and pepo has been given a "Read Non-Private Data" OAuth permission for ~ubuntu-archive.

[lp:~cjwatson/ubuntu-archive-publishing/add-germinate-scripts]

43. By Colin Watson on 2014-06-09

Remove comment reference to GlobalLock.

44. By Colin Watson on 2014-06-09

The webservice spells it architecture_tag, not architecturetag.

[William Grant (wgrant)]

review: Approve (code)

[Colin Watson (cjwatson)]

William accurately points out that we're using login_anonymously so the OAuth permission for ~ubuntu-archive is unnecessary.

=== modified file 'finalize.d/20-germinate'
--- finalize.d/20-germinate	2014-04-15 15:55:56 +0000
+++ finalize.d/20-germinate	2014-06-09 13:57:00 +0000
@@ -2,5 +2,5 @@
 
 if [ "$SECURITY_UPLOAD_ONLY" != "yes" ]
 then
-    cron.germinate || /bin/true
+    "$(dirname "$0")/../scripts/cron.germinate" || /bin/true
 fi

=== added directory 'lib'
=== added directory 'lib/scripts'
=== added file 'lib/scripts/__init__.py'
=== added file 'lib/scripts/generate_extra_overrides.py'
--- lib/scripts/generate_extra_overrides.py	1970-01-01 00:00:00 +0000
+++ lib/scripts/generate_extra_overrides.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,518 @@
+#! /usr/bin/python
+#
+# Copyright 2011-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Generate extra overrides using Germinate."""
+
+__metaclass__ = type
+__all__ = [
+    'GenerateExtraOverrides',
+    ]
+
+import errno
+import fcntl
+from functools import partial
+import glob
+import logging
+from optparse import (
+    OptionParser,
+    OptionValueError,
+    )
+import os
+import re
+import sys
+import time
+
+from germinate.archive import TagFile
+from germinate.germinator import Germinator
+from germinate.log import GerminateFormatter
+from germinate.seeds import (
+    SeedError,
+    SeedStructure,
+    )
+from launchpadlib.launchpad import Launchpad
+
+
+LOCK_PATH = "/var/lock/"
+
+
+def file_exists(filename):
+    """Does `filename` exist?"""
+    return os.access(filename, os.F_OK)
+
+
+class ScriptFormatter(logging.Formatter):
+    """logging.Formatter encoding our preferred output format."""
+
+    def __init__(self, fmt=None, datefmt="%Y-%m-%d %H:%M:%S"):
+        if fmt is None:
+            fmt = '%(asctime)s %(levelname)-7s %(message)s'
+        logging.Formatter.__init__(self, fmt, datefmt)
+        # Output should be UTC.
+        self.converter = time.gmtime
+
+
+def log_unhandled_exception_and_exit(func):
+    """Decorator that logs unhandled exceptions via the logging module.
+
+    Exceptions are reraised except at the top level. ie. exceptions are
+    only propagated to the outermost decorated method. At the top level,
+    an exception causes the script to terminate.
+    """
+
+    def log_unhandled_exceptions_func(self, *args, **kw):
+        try:
+            self._log_unhandled_exceptions_level += 1
+            return func(self, *args, **kw)
+        except Exception:
+            if self._log_unhandled_exceptions_level == 1:
+                # self.logger is setup in GenerateExtraOverrides.__init__()
+                # so we can use it.
+                self.logger.exception("Unhandled exception")
+                sys.exit(1)
+            else:
+                raise
+        finally:
+            self._log_unhandled_exceptions_level -= 1
+    return log_unhandled_exceptions_func
+
+
+class ScriptFailure(Exception):
+    """Something bad happened and the script is going away."""
+
+
+class AtomicFile:
+    """Facilitate atomic writing of files."""
+
+    def __init__(self, filename):
+        self.filename = filename
+        self.fd = open("%s.new" % self.filename, "w")
+
+    def __enter__(self):
+        return self.fd
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        self.fd.close()
+        if exc_type is None:
+            os.rename("%s.new" % self.filename, self.filename)
+
+
+def find_operable_series(distribution):
+    """Find all the series we can operate on in this distribution.
+
+    We are allowed to modify DEVELOPMENT or FROZEN series, but should leave
+    series with any other status alone.
+    """
+    return [
+        series for series in distribution.series
+        if series.status in ("Active Development", "Pre-release Freeze")]
+
+
+class GenerateExtraOverrides:
+    """Main class for generating extra overrides."""
+
+    # State for the log_unhandled_exceptions_and_exit decorator.
+    _log_unhandled_exceptions_level = 0
+
+    def __init__(self, name=None, test_args=None):
+        if name is None:
+            self._name = self.__class__.__name__.lower()
+        else:
+            self._name = name
+        self.parser = OptionParser()
+        self.add_my_options()
+        self.options, self.args = self.parser.parse_args(args=test_args)
+
+        self.logger = logging.getLogger()
+        hdlr = logging.StreamHandler()
+        self.logger.setLevel(0)
+        hdlr.setLevel(logging.DEBUG)
+        hdlr.setFormatter(ScriptFormatter())
+        self.logger.addHandler(hdlr)
+
+        self.germinate_logger = None
+
+    def add_my_options(self):
+        """Add a 'distribution' context option."""
+        self.parser.add_option(
+            "-l", "--launchpad", dest="launchpad_instance",
+            default="production")
+        self.parser.add_option(
+            "-d", "--distribution", dest="distribution",
+            help="Context distribution name.")
+
+    @property
+    def name(self):
+        # Include distribution name.  Clearer to admins, but also
+        # puts runs for different distributions under separate
+        # locks so that they can run simultaneously.
+        return "%s-%s" % (self._name, self.options.distribution)
+
+    @property
+    def lockfilename(self):
+        return "launchpad-%s.lock" % self.name
+
+    @property
+    def lockfilepath(self):
+        return os.path.join(LOCK_PATH, self.lockfilename)
+
+    def setup_lock(self):
+        """Create lockfile.
+
+        Note that this will create a lockfile even if you don't actually
+        use it.
+        """
+        if os.path.exists(self.lockfilepath):
+            self.previous_lockfile_present = True
+        else:
+            self.previous_lockfile_present = False
+        self.flock = open(self.lockfilepath, "w")
+        self.fdlock = self.flock.fileno()
+
+    @log_unhandled_exception_and_exit
+    def lock_or_die(self):
+        """Attempt to lock, and sys.exit(1) if the lock's already taken."""
+        self.setup_lock()
+        self.logger.info("Creating lockfile: %s", self.lockfilepath)
+        try:
+            fcntl.flock(self.fdlock, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        except IOError as message:
+            match = re.search("^\[Errno ([0-9]+)\]", str(message))
+            if match:
+                if int(match.group(1)) == errno.EWOULDBLOCK:
+                    self.logger.info('Lockfile %s in use' % self.lockfilepath)
+                    sys.exit(1)
+                else:
+                    raise Exception(
+                        'Cannot acquire lock on file "%s": %s' %
+                        (self.lockfilepath, message))
+            else:
+                raise Exception('Malformed error message "%s"' % message)
+        if self.previous_lockfile_present:
+            self.logger.warn("Stale lockfile detected and claimed.")
+        self.is_locked = True
+
+    @log_unhandled_exception_and_exit
+    def unlock(self):
+        """Release the lock. Do this before going home."""
+        if not self.is_locked:
+            return
+        self.logger.debug('Removing lock file: %s', self.lockfilepath)
+        os.unlink(self.lockfilepath)
+        try:
+            fcntl.flock(self.fdlock, fcntl.LOCK_UN)
+        except IOError:
+            raise Exception('Unlock of file "%s" failed' % self.lockfilepath)
+        self.is_locked = False
+
+    @log_unhandled_exception_and_exit
+    def run(self):
+        """Actually run the script."""
+        try:
+            self.main()
+        except ScriptFailure as e:
+            self.logger.error(str(e))
+            sys.exit(1)
+
+    @log_unhandled_exception_and_exit
+    def lock_and_run(self):
+        """Call lock_or_die(), and then run() the script.
+
+        Will die with sys.exit(1) if the locking call fails.
+        """
+        self.lock_or_die()
+        try:
+            self.run()
+        finally:
+            self.unlock()
+
+    def login(self):
+        return Launchpad.login_anonymously(
+            self.name, self.options.launchpad_instance)
+
+    def processOptions(self):
+        """Handle command-line options."""
+        self.options.launchpad = self.login()
+
+        if self.options.distribution is None:
+            raise OptionValueError("Specify a distribution.")
+
+        try:
+            self.distribution = self.options.launchpad.distributions[
+                self.options.distribution]
+        except KeyError:
+            raise OptionValueError(
+                "Distribution '%s' not found." % self.options.distribution)
+
+        self.series = find_operable_series(self.distribution)
+        if not self.series:
+            raise ScriptFailure(
+                "There is no DEVELOPMENT or FROZEN distroseries for %s." %
+                self.options.distribution)
+
+        # The finalize.d protocol passes the list of root directories for
+        # the distribution's archives in the ARCHIVEROOTS environment
+        # variable, joined by spaces.  We only care about the first archive.
+        self.archiveroot = os.environ["ARCHIVEROOTS"].split()[0]
+        self.germinateroot = self.archiveroot + "-germinate"
+        self.miscroot = self.archiveroot + "-misc"
+
+    def setUpDirs(self):
+        """Create output directories if they did not already exist."""
+        if not file_exists(self.germinateroot):
+            self.logger.debug(
+                "Creating germinate root %s.", self.germinateroot)
+            os.makedirs(self.germinateroot)
+        if not file_exists(self.miscroot):
+            self.logger.debug("Creating misc root %s.", self.miscroot)
+            os.makedirs(self.miscroot)
+
+    def addLogHandler(self):
+        """Send germinate's log output to a separate file."""
+        if self.germinate_logger is not None:
+            return
+
+        self.germinate_logger = logging.getLogger("germinate")
+        self.germinate_logger.setLevel(logging.INFO)
+        self.log_file = os.path.join(self.germinateroot, "germinate.output")
+        handler = logging.FileHandler(self.log_file, mode="w")
+        handler.setFormatter(GerminateFormatter())
+        self.germinate_logger.addHandler(handler)
+        self.germinate_logger.propagate = False
+
+    def setUp(self):
+        """Process options, and set up internal state."""
+        self.processOptions()
+        self.setUpDirs()
+        self.addLogHandler()
+
+    def getComponents(self, series):
+        """Get the list of components to process for a given distroseries.
+
+        Even if DistroSeries.component_names starts including partner,
+        we don't want it; this applies to the primary archive only.
+        """
+        return [component
+                for component in series.component_names
+                if component != "partner"]
+
+    def makeSeedStructures(self, series_name, flavours, seed_bases=None):
+        structures = {}
+        for flavour in flavours:
+            try:
+                structure = SeedStructure(
+                    "%s.%s" % (flavour, series_name), seed_bases=seed_bases)
+                if len(structure):
+                    structures[flavour] = structure
+                else:
+                    self.logger.warning(
+                        "Skipping empty seed structure for %s.%s",
+                        flavour, series_name)
+            except SeedError as e:
+                self.logger.warning(
+                    "Failed to fetch seeds for %s.%s: %s",
+                    flavour, series_name, e)
+        return structures
+
+    def logGerminateProgress(self, *args):
+        """Log a "progress" entry to the germinate log file.
+
+        Germinate logs quite a bit of detailed information.  To make it
+        easier to see the structure of its operation, GerminateFormatter
+        allows tagging some log entries as "progress" entries, which are
+        printed without a prefix.
+        """
+        self.germinate_logger.info(*args, extra={"progress": True})
+
+    def composeOutputPath(self, flavour, series_name, arch, base):
+        return os.path.join(
+            self.germinateroot,
+            "%s_%s_%s_%s" % (base, flavour, series_name, arch))
+
+    def recordOutput(self, path, seed_outputs):
+        if seed_outputs is not None:
+            seed_outputs.add(os.path.basename(path))
+
+    def writeGerminateOutput(self, germinator, structure, flavour,
+                             series_name, arch, seed_outputs=None):
+        """Write dependency-expanded output files.
+
+        These files are a reduced subset of those written by the germinate
+        command-line program.
+        """
+        path = partial(self.composeOutputPath, flavour, series_name, arch)
+
+        # The structure file makes it possible to figure out how the other
+        # output files relate to each other.
+        structure.write(path("structure"))
+        self.recordOutput(path("structure"), seed_outputs)
+
+        # "all" and "all.sources" list the full set of binary and source
+        # packages respectively for a given flavour/suite/architecture
+        # combination.
+        germinator.write_all_list(structure, path("all"))
+        self.recordOutput(path("all"), seed_outputs)
+        germinator.write_all_source_list(structure, path("all.sources"))
+        self.recordOutput(path("all.sources"), seed_outputs)
+
+        # Write the dependency-expanded output for each seed.  Several of
+        # these are used by archive administration tools, and others are
+        # useful for debugging, so it's best to just write them all.
+        for seedname in structure.names:
+            germinator.write_full_list(structure, path(seedname), seedname)
+            self.recordOutput(path(seedname), seed_outputs)
+
+    def parseTaskHeaders(self, seedtext):
+        """Parse a seed for Task headers.
+
+        seedtext is a file-like object.  Return a dictionary of Task headers,
+        with keys canonicalised to lower-case.
+        """
+        task_headers = {}
+        task_header_regex = re.compile(
+            r"task-(.*?):(.*)", flags=re.IGNORECASE)
+        for line in seedtext:
+            match = task_header_regex.match(line)
+            if match is not None:
+                key, value = match.groups()
+                task_headers[key.lower()] = value.strip()
+        return task_headers
+
+    def getTaskName(self, task_headers, flavour, seedname, primary_flavour):
+        """Work out the name of the Task to be generated from this seed.
+
+        If there is a Task-Name header, it wins; otherwise, seeds with a
+        Task-Per-Derivative header are honoured for all flavours and put in
+        an appropriate namespace, while other seeds are only honoured for
+        the first flavour and have archive-global names.
+        """
+        if "name" in task_headers:
+            return task_headers["name"]
+        elif "per-derivative" in task_headers:
+            return "%s-%s" % (flavour, seedname)
+        elif primary_flavour:
+            return seedname
+        else:
+            return None
+
+    def getTaskSeeds(self, task_headers, seedname):
+        """Return the list of seeds used to generate a task from this seed.
+
+        The list of packages in this task comes from this seed plus any
+        other seeds listed in a Task-Seeds header.
+        """
+        scan_seeds = set([seedname])
+        if "seeds" in task_headers:
+            scan_seeds.update(task_headers["seeds"].split())
+        return sorted(scan_seeds)
+
+    def writeOverrides(self, override_file, germinator, structure, arch,
+                       seedname, key, value):
+        packages = germinator.get_full(structure, seedname)
+        for package in sorted(packages):
+            print >>override_file, "%s/%s  %s  %s" % (
+                package, arch, key, value)
+
+    def germinateArchFlavour(self, override_file, germinator, series_name,
+                             arch, flavour, structure, primary_flavour,
+                             seed_outputs=None):
+        """Germinate seeds on a single flavour for a single architecture."""
+        # Expand dependencies.
+        germinator.plant_seeds(structure)
+        germinator.grow(structure)
+        germinator.add_extras(structure)
+
+        self.writeGerminateOutput(
+            germinator, structure, flavour, series_name, arch,
+            seed_outputs=seed_outputs)
+
+        write_overrides = partial(
+            self.writeOverrides, override_file, germinator, structure, arch)
+
+        # Generate apt-ftparchive "extra overrides" for Task fields.
+        seednames = [name for name in structure.names if name != "extra"]
+        for seedname in seednames:
+            with structure[seedname] as seedtext:
+                task_headers = self.parseTaskHeaders(seedtext)
+            if task_headers:
+                task = self.getTaskName(
+                    task_headers, flavour, seedname, primary_flavour)
+                if task is not None:
+                    scan_seeds = self.getTaskSeeds(task_headers, seedname)
+                    for scan_seed in scan_seeds:
+                        write_overrides(scan_seed, "Task", task)
+
+        # Generate apt-ftparchive "extra overrides" for Build-Essential
+        # fields.
+        if "build-essential" in structure.names and primary_flavour:
+            write_overrides("build-essential", "Build-Essential", "yes")
+
+    def germinateArch(self, override_file, series_name, components, arch,
+                      flavours, structures, seed_outputs=None):
+        """Germinate seeds on all flavours for a single architecture."""
+        germinator = Germinator(arch)
+
+        # Read archive metadata.
+        archive = TagFile(
+            series_name, components, arch, "file://%s" % self.archiveroot,
+            cleanup=True)
+        germinator.parse_archive(archive)
+
+        for flavour in flavours:
+            self.logger.info(
+                "Germinating for %s/%s/%s", flavour, series_name, arch)
+            # Add this to the germinate log as well so that that can be
+            # debugged more easily.  Log a separator line first.
+            self.logGerminateProgress("")
+            self.logGerminateProgress(
+                "Germinating for %s/%s/%s", flavour, series_name, arch)
+
+            self.germinateArchFlavour(
+                override_file, germinator, series_name, arch, flavour,
+                structures[flavour], flavour == flavours[0],
+                seed_outputs=seed_outputs)
+
+    def removeStaleOutputs(self, series_name, seed_outputs):
+        """Remove stale outputs for a series.
+
+        Any per-seed outputs not in seed_outputs are considered stale.
+        """
+        all_outputs = glob.glob(
+            os.path.join(self.germinateroot, "*_*_%s_*" % series_name))
+        for output in all_outputs:
+            if os.path.basename(output) not in seed_outputs:
+                os.remove(output)
+
+    def generateExtraOverrides(self, series_name, components, architectures,
+                               flavours, seed_bases=None):
+        structures = self.makeSeedStructures(
+            series_name, flavours, seed_bases=seed_bases)
+
+        if structures:
+            seed_outputs = set()
+            override_path = os.path.join(
+                self.miscroot, "more-extra.override.%s.main" % series_name)
+            with AtomicFile(override_path) as override_file:
+                for arch in architectures:
+                    self.germinateArch(
+                        override_file, series_name, components, arch,
+                        flavours, structures, seed_outputs=seed_outputs)
+            self.removeStaleOutputs(series_name, seed_outputs)
+
+    def process(self, seed_bases=None):
+        """Do the bulk of the work."""
+        self.setUp()
+
+        for series in self.series:
+            series_name = series.name
+            components = self.getComponents(series)
+            architectures = sorted(
+                arch.architecture_tag for arch in series.architectures)
+
+            self.generateExtraOverrides(
+                series_name, components, architectures, self.args,
+                seed_bases=seed_bases)
+
+    def main(self):
+        self.process()

=== added directory 'scripts'
=== added file 'scripts/cron.germinate'
--- scripts/cron.germinate	1970-01-01 00:00:00 +0000
+++ scripts/cron.germinate	2014-06-09 13:57:00 +0000
@@ -0,0 +1,62 @@
+#! /bin/sh
+#
+# Copyright 2009-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+set -e
+set -u
+
+ARCHIVEROOT=${TEST_ARCHIVEROOT:-/srv/launchpad.net/ubuntu-archive/ubuntu}
+MISCROOT=$ARCHIVEROOT/../ubuntu-misc
+LOCKROOT=$ARCHIVEROOT/..
+GERMINATEROOT=$ARCHIVEROOT/../ubuntu-germinate
+
+LAUNCHPADROOT=${TEST_LAUNCHPADROOT:-/srv/launchpad.net/production/launchpad}
+SCRIPTSROOT=${TEST_SCRIPTSROOT:-`dirname $0`/..}
+GENERATE=$SCRIPTSROOT/scripts/generate-extra-overrides.py
+MAINTENANCE_CHECK=$SCRIPTSROOT/scripts/maintenance-check.py
+
+FLAVOURS="ubuntu kubuntu kubuntu-active edubuntu xubuntu mythbuntu lubuntu"
+FLAVOURS="$FLAVOURS ubuntustudio ubuntu-gnome ubuntu-touch"
+
+## Check to see if another germinate run is in progress
+
+LOCKFILE=$LOCKROOT/cron.germinate.lock
+if lockfile -! -l 43200 -r 0 "${LOCKFILE}"; then
+  echo Another cron.germinate appears to be running
+  exit 1
+fi
+
+cleanup () {
+  rm -f "$LOCKFILE"
+}
+
+trap cleanup EXIT
+
+cd $GERMINATEROOT
+
+$GENERATE -d ubuntu $FLAVOURS
+
+# Now generate the Supported extra overrides for all supported distros.
+SUITES=`$LAUNCHPADROOT/scripts/ftpmaster-tools/lp-query-distro.py supported`
+for supported_suite in $SUITES; do
+    echo -n "Running maintenance-check for $supported_suite... "
+    # The support timeframe information is stored here
+    SUPPORTED="$MISCROOT/more-extra.override.$supported_suite.main.supported"
+    # This is the target override file that contains germinate plus
+    # support info.
+    TARGET="$MISCROOT/more-extra.override.$supported_suite.main"
+    # Debug/Log information
+    LOG="_maintenance-check.$supported_suite.stderr"
+    if $MAINTENANCE_CHECK $supported_suite > $SUPPORTED 2> $LOG; then
+        # The target file may be missing on the server and the script should
+        # not fail if that is the case.
+        touch $TARGET
+        # Remove old "Supported" info from extra-overrides as it may be
+        # stale now and we replace it with fresh content below.
+        sed /"^.* Supported"/d $TARGET > ${TARGET}.new
+        cat $SUPPORTED >> ${TARGET}.new
+        mv ${TARGET}.new $TARGET
+    fi
+    echo " done"
+done

=== added file 'scripts/generate-extra-overrides.py'
--- scripts/generate-extra-overrides.py	1970-01-01 00:00:00 +0000
+++ scripts/generate-extra-overrides.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,18 @@
+#!/usr/bin/python
+#
+# Copyright 2011-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Generate extra overrides using Germinate."""
+
+import os
+import sys
+
+sys.path.insert(0, os.path.join(sys.path[0], os.pardir, "lib"))
+
+from scripts.generate_extra_overrides import GenerateExtraOverrides
+
+
+if __name__ == '__main__':
+    script = GenerateExtraOverrides("generate-extra-overrides")
+    script.lock_and_run()

=== added file 'scripts/maintenance-check.py'
--- scripts/maintenance-check.py	1970-01-01 00:00:00 +0000
+++ scripts/maintenance-check.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,529 @@
+#!/usr/bin/python
+#
+# python port of the nice maintainace-check script by  Nick Barcet
+#
+
+import logging
+from optparse import OptionParser
+import os
+import sys
+import urllib2
+import urlparse
+
+import apt
+import apt_pkg
+
+
+class UbuntuMaintenance(object):
+    """ Represents the support timeframe for a regular ubuntu release """
+
+    # architectures that are full supported (including LTS time)
+    PRIMARY_ARCHES = [
+        "i386",
+        "amd64",
+        ]
+
+    # architectures we support (but not for LTS time)
+    SUPPORTED_ARCHES = PRIMARY_ARCHES + [
+        "armel",
+        "armhf",
+        "arm64",
+        "ppc64el",
+        ]
+
+    # what defines the seeds is documented in wiki.ubuntu.com/SeedManagement
+    SERVER_SEEDS = [
+        "server-ship",
+        "supported-server",
+        ]
+    DESKTOP_SEEDS = [
+        "ship",
+        "supported-desktop",
+        "supported-desktop-extra",
+        ]
+    SUPPORTED_SEEDS = ["all"]
+
+    # normal support timeframe
+    # time, seeds
+    SUPPORT_TIMEFRAME = [
+        ("9m", SUPPORTED_SEEDS),
+        ]
+
+    # shorter than normal support timeframe
+    # time, seed
+    SUPPORT_TIMEFRAME_SHORT = [
+        ]
+
+    # distro names that we check the seeds for
+    DISTRO_NAMES = [
+        "ubuntu",
+        ]
+
+    # distro names for shorter than default support cycles
+    DISTRO_NAMES_SHORT = [
+        ]
+
+
+# This is fun! We have a bunch of cases for 10.04 LTS
+#
+#  - distro "ubuntu" follows SUPPORT_TIMEFRAME_LTS but only for
+#    amd64/i386
+#  - distros "kubuntu", "edubuntu" and "netbook" need to be
+#    considered *but* only follow SUPPORT_TIMEFRAME
+#  - anything that is in armel follows SUPPORT_TIMEFRAME
+#
+class LucidUbuntuMaintenance(UbuntuMaintenance):
+    """ Represents the support timeframe for a 10.04 (lucid) LTS release,
+        the exact rules differ from LTS release to LTS release
+    """
+
+    # lts support timeframe, order is important, least supported must be last
+    # time, seeds
+    SUPPORT_TIMEFRAME = [
+        ("5y",  UbuntuMaintenance.SERVER_SEEDS),
+        ("3y",  UbuntuMaintenance.DESKTOP_SEEDS),
+        ("18m", UbuntuMaintenance.SUPPORTED_SEEDS),
+        ]
+
+    # on a LTS this is significant, it defines what names get LTS support
+    DISTRO_NAMES = [
+        "ubuntu",
+        "kubuntu",
+        ]
+
+
+class PreciseUbuntuMaintenance(UbuntuMaintenance):
+    """ The support timeframe for the 12.04 (precise) LTS release.
+        This changes the timeframe for desktop packages from 3y to 5y
+    """
+
+    # lts support timeframe, order is important, least supported must be last
+    # time, seeds
+    SUPPORT_TIMEFRAME = [
+        ("5y", UbuntuMaintenance.SERVER_SEEDS),
+        ("5y", UbuntuMaintenance.DESKTOP_SEEDS),
+        ("18m", UbuntuMaintenance.SUPPORTED_SEEDS),
+        ]
+
+    # on a LTS this is significant, it defines what names get LTS support
+    DISTRO_NAMES = [
+        "ubuntu",
+        "kubuntu",
+        ]
+
+
+class QuantalUbuntuMaintenance(UbuntuMaintenance):
+
+    SUPPORT_TIMEFRAME = [
+        ("18m", UbuntuMaintenance.SUPPORTED_SEEDS),
+        ]
+
+
+OneiricUbuntuMaintenance = QuantalUbuntuMaintenance
+
+
+class TrustyUbuntuMaintenance(UbuntuMaintenance):
+    """ The support timeframe for the 14.04 (trusty) LTS release.
+        This changes the timeframe for desktop packages from 3y to 5y
+    """
+
+    # lts support timeframe, order is important, least supported must be last
+    # time, seeds
+    SUPPORT_TIMEFRAME = [
+        ("5y", UbuntuMaintenance.SERVER_SEEDS),
+        ("5y", UbuntuMaintenance.DESKTOP_SEEDS),
+        ("9m", UbuntuMaintenance.SUPPORTED_SEEDS),
+        ]
+
+    SUPPORT_TIMEFRAME_SHORT = [
+        ("3y", UbuntuMaintenance.SERVER_SEEDS),
+        ("3y", UbuntuMaintenance.DESKTOP_SEEDS),
+        ("9m", UbuntuMaintenance.SUPPORTED_SEEDS),
+        ]
+        
+    # on a LTS this is significant, it defines what names get LTS support
+    #
+    # Kylin is not in this list, becuase it's not seed managed =/,
+    # it is LTS however as per 2014-03-17 Ubuntu TechBoard meeting
+    DISTRO_NAMES = [
+        "ubuntu",
+        "kubuntu",
+        "edubuntu",
+        ]
+
+    DISTRO_NAMES_SHORT = [
+        "ubuntu-gnome",
+        "xubuntu",
+        "mythbuntu",
+        "ubuntustudio",
+        "lubuntu",
+        ]
+
+
+# Names of the distribution releases that are not supported by this
+# tool. All later versions are supported.
+UNSUPPORTED_DISTRO_RELEASED = [
+    "dapper",
+    "edgy",
+    "feisty",
+    "gutsy",
+    "hardy",
+    "intrepid",
+    "jaunty",
+    "karmic",
+    ]
+
+
+# germinate output base directory
+BASE_URL = os.environ.get(
+    "MAINTENANCE_CHECK_BASE_URL",
+    "http://people.canonical.com/~ubuntu-archive/germinate-output/")
+
+# hints dir url, hints file is "$distro.hints" by default
+# (e.g. lucid.hints)
+HINTS_DIR_URL = os.environ.get(
+    "MAINTENANCE_CHECK_HINTS_DIR_URL",
+    "http://people.canonical.com/"
+        "~ubuntu-archive/seeds/platform.%s/SUPPORTED_HINTS")
+
+# we need the archive root to parse the Sources file to support
+# by-source hints
+ARCHIVE_ROOT = os.environ.get(
+    "MAINTENANCE_CHECK_ARCHIVE_ROOT", "http://archive.ubuntu.com/ubuntu")
+
+# support timeframe tag used in the Packages file
+SUPPORT_TAG = "Supported"
+
+
+def get_binaries_for_source_pkg(srcname):
+    """ Return all binary package names for the given source package name.
+
+    :param srcname: The source package name.
+    :return: A list of binary package names.
+    """
+    pkgnames = set()
+    recs = apt_pkg.SourceRecords()
+    while recs.lookup(srcname):
+        for binary in recs.binaries:
+            pkgnames.add(binary)
+    return pkgnames
+
+
+def expand_src_pkgname(pkgname):
+    """ Expand a package name if it is prefixed with src.
+
+    If the package name is prefixed with src it will be expanded
+    to a list of binary package names. Otherwise the original
+    package name will be returned.
+
+    :param pkgname: The package name (that may include src:prefix).
+    :return: A list of binary package names (the list may be one element
+             long).
+    """
+    if not pkgname.startswith("src:"):
+        return [pkgname]
+    return get_binaries_for_source_pkg(pkgname.split("src:")[1])
+
+
+def create_and_update_deb_src_source_list(distroseries):
+    """ Create sources.list and update cache.
+
+    This creates a sources.list file with deb-src entries for a given
+    distroseries and apt.Cache.update() to make sure the data is up-to-date.
+    :param distro: The code name of the distribution series (e.g. lucid).
+    :return: None
+    :raises: IOError: When cache update fails.
+    """
+    # apt root dir
+    rootdir = "./aptroot.%s" % distroseries
+    sources_list_dir = os.path.join(rootdir, "etc", "apt")
+    if not os.path.exists(sources_list_dir):
+        os.makedirs(sources_list_dir)
+    sources_list = open(os.path.join(sources_list_dir, "sources.list"), "w")
+    for pocket in [
+        "%s" % distroseries,
+        "%s-updates" % distroseries,
+        "%s-security" % distroseries]:
+        sources_list.write(
+            "deb-src %s %s main restricted\n" % (
+                ARCHIVE_ROOT, pocket))
+        sources_list.write(
+            "deb %s %s main restricted\n" % (
+                ARCHIVE_ROOT, pocket))
+    sources_list.close()
+    # create required dirs/files for apt.Cache(rootdir) to work on older
+    # versions of python-apt. once lucid is used it can be removed
+    for d in ["var/lib/dpkg",
+              "var/cache/apt/archives/partial",
+              "var/lib/apt/lists/partial"]:
+        if not os.path.exists(os.path.join(rootdir, d)):
+            os.makedirs(os.path.join(rootdir, d))
+    if not os.path.exists(os.path.join(rootdir, "var/lib/dpkg/status")):
+        open(os.path.join(rootdir, "var/lib/dpkg/status"), "w")
+    # open cache with our just prepared rootdir
+    cache = apt.Cache(rootdir=rootdir)
+    try:
+        cache.update()
+    except SystemError:
+        logging.exception("cache.update() failed")
+
+
+def get_structure(distroname, version):
+    """ Get structure file conent for named distro and distro version.
+
+    :param name: Name of the distribution (e.g. kubuntu, ubuntu, xubuntu).
+    :param version: Code name of the distribution version (e.g. lucid).
+    :return: List of strings with the structure file content
+    """
+    f = urllib2.urlopen("%s/%s.%s/structure" % (
+            BASE_URL, distroname, version))
+    structure = f.readlines()
+    f.close()
+    return structure
+
+
+def expand_seeds(structure, seedname):
+    """Expand seed by its dependencies using the strucure file.
+
+    :param structure: The content of the STRUCTURE file as string list.
+    :param seedname: The name of the seed as string that needs to be expanded.
+    :return: A set() for the seed dependencies (excluding the original
+        seedname).
+    """
+    seeds = []
+    for line in structure:
+        if line.startswith("%s:" % seedname):
+            seeds += line.split(":")[1].split()
+            for seed in seeds:
+                seeds += expand_seeds(structure, seed)
+    return set(seeds)
+
+
+def get_packages_for_seeds(name, distro, seeds):
+    """
+    Get packages for the given name (e.g. ubuntu) and distro release
+    (e.g. lucid) that are in the given list of seeds
+    returns a set() of package names.
+    """
+    pkgs_in_seeds = {}
+    for seed in seeds:
+        pkgs_in_seeds[seed] = set()
+        seedurl = "%s/%s.%s/%s" % (BASE_URL, name, distro, seed)
+        logging.debug("looking for '%s'", seedurl)
+        try:
+            f = urllib2.urlopen(seedurl)
+            for line in f:
+                # Ignore lines that are not package names (headers etc).
+                if line[0] < 'a' or line[0] > 'z':
+                    continue
+                # Each line contains these fields:
+                # (package, source, why, maintainer, size, inst-size)
+                if options.source_packages:
+                    pkgname = line.split("|")[1]
+                else:
+                    pkgname = line.split("|")[0]
+                pkgs_in_seeds[seed].add(pkgname.strip())
+            f.close()
+        except Exception as e:
+            logging.error("seed %s failed (%s)" % (seedurl, e))
+    return pkgs_in_seeds
+
+
+def what_seeds(pkgname, seeds):
+    in_seeds = set()
+    for s in seeds:
+        if pkgname in seeds[s]:
+            in_seeds.add(s)
+    return in_seeds
+
+
+def compare_support_level(x, y):
+    """
+    compare two support level strings of the form 18m, 3y etc
+    :parm x: the first support level
+    :parm y: the second support level
+    :return: negative if x < y, zero if x==y, positive if x > y
+    """
+
+    def support_to_int(support_time):
+        """
+        helper that takes a support time string and converts it to
+        a integer for cmp()
+        """
+        # allow strings like "5y (kubuntu-common)
+        x = support_time.split()[0]
+        if x.endswith("y"):
+            return 12 * int(x[0:-1])
+        elif x.endswith("m"):
+            return int(x[0:-1])
+        else:
+            raise ValueError("support time '%s' has to end with y or m" % x)
+    return cmp(support_to_int(x), support_to_int(y))
+
+
+def get_packages_support_time(structure, name, pkg_support_time,
+                              support_timeframe_list):
+    """
+    input a structure file and a list of pair<timeframe, seedlist>
+    return a dict of pkgnames -> support timeframe string
+    """
+    for (timeframe, seedlist) in support_timeframe_list:
+        expanded = set()
+        for s in seedlist:
+            expanded.add(s)
+            expanded |= expand_seeds(structure, s)
+        pkgs_in_seeds = get_packages_for_seeds(name, distro, expanded)
+        for seed in pkgs_in_seeds:
+            for pkg in pkgs_in_seeds[seed]:
+                if not pkg in pkg_support_time:
+                    pkg_support_time[pkg] = timeframe
+                else:
+                    old_timeframe = pkg_support_time[pkg]
+                    if compare_support_level(old_timeframe, timeframe) < 0:
+                        logging.debug("overwriting %s from %s to %s" % (
+                                pkg, old_timeframe, timeframe))
+                        pkg_support_time[pkg] = timeframe
+                if options.with_seeds:
+                    pkg_support_time[pkg] += " (%s)" % ", ".join(
+                        what_seeds(pkg, pkgs_in_seeds))
+
+    return pkg_support_time
+
+
+if __name__ == "__main__":
+    parser = OptionParser()
+    parser.add_option("--with-seeds", "", default=False,
+                      action="store_true",
+                      help="add seed(s) of the package that are responsible "
+                           "for the maintaince time")
+    parser.add_option("--source-packages", "", default=False,
+                      action="store_true",
+                      help="show as source pkgs")
+    parser.add_option("--hints-file", "", default=None,
+                      help="use diffenrt use hints file location")
+    (options, args) = parser.parse_args()
+
+    # init
+    if len(args) > 0:
+        distro = args[0]
+        if distro in UNSUPPORTED_DISTRO_RELEASED:
+            logging.error("only lucid or later is supported")
+            sys.exit(1)
+    else:
+        distro = "lucid"
+
+    # maintenance class to use
+    klass = globals().get("%sUbuntuMaintenance" % distro.capitalize())
+    if klass is None:
+        klass = UbuntuMaintenance
+    ubuntu_maintenance = klass()
+
+    # make sure our deb-src information is up-to-date
+    create_and_update_deb_src_source_list(distro)
+
+    if options.hints_file:
+        hints_file = options.hints_file
+        (schema, netloc, path, query, fragment) = urlparse.urlsplit(
+            hints_file)
+        if not schema:
+            hints_file = "file:%s" % path
+    else:
+        hints_file = HINTS_DIR_URL % distro
+
+    # go over the distros we need to check
+    pkg_support_time = {}
+    for names, support_timeframe in (
+            (ubuntu_maintenance.DISTRO_NAMES_SHORT, ubuntu_maintenance.SUPPORT_TIMEFRAME_SHORT),
+            (ubuntu_maintenance.DISTRO_NAMES, ubuntu_maintenance.SUPPORT_TIMEFRAME),
+            ):
+        for name in names:
+            # get basic structure file
+            try:
+                structure = get_structure(name, distro)
+            except urllib2.HTTPError:
+                logging.error("Can not get structure for '%s'." % name)
+                continue
+
+            # get dicts of pkgname -> support timeframe string
+            get_packages_support_time(
+                structure, name, pkg_support_time, support_timeframe)
+
+    # now go over the bits in main that we have not seen (because
+    # they are not in any seed and got added manually into "main"
+    for arch in ubuntu_maintenance.PRIMARY_ARCHES:
+        rootdir = "./aptroot.%s" % distro
+        apt_pkg.config.set("APT::Architecture", arch)
+        cache = apt.Cache(rootdir=rootdir)
+        try:
+            cache.update()
+        except SystemError:
+            logging.exception("cache.update() failed")
+        cache.open()
+        for pkg in cache:
+            # ignore multiarch package names
+            if ":" in pkg.name:
+                continue
+            if not pkg.name in pkg_support_time:
+                pkg_support_time[pkg.name] = support_timeframe[-1][0]
+                logging.warn(
+                    "add package in main but not in seeds %s with %s" % (
+                        pkg.name, pkg_support_time[pkg.name]))
+
+    # now check the hints file that is used to overwrite
+    # the default seeds
+    try:
+        for line in urllib2.urlopen(hints_file):
+            line = line.strip()
+            if not line or line.startswith("#"):
+                continue
+            try:
+                (raw_pkgname, support_time) = line.split()
+                for pkgname in expand_src_pkgname(raw_pkgname):
+                    if support_time == 'unsupported':
+                        try:
+                            del pkg_support_time[pkgname]
+                            sys.stderr.write("hints-file: marking %s "
+                                             "unsupported\n" % pkgname)
+                        except KeyError:
+                            pass
+                    else:
+                        if pkg_support_time.get(pkgname) != support_time:
+                            sys.stderr.write(
+                                "hints-file: changing %s from %s to %s\n" % (
+                                    pkgname, pkg_support_time.get(pkgname),
+                                    support_time))
+                            pkg_support_time[pkgname] = support_time
+            except:
+                logging.exception("can not parse line '%s'" % line)
+    except urllib2.HTTPError as e:
+        if e.code != 404:
+            raise
+        sys.stderr.write("hints-file: %s gave 404 error\n" % hints_file)
+
+    # output suitable for the extra-override file
+    for pkgname in sorted(pkg_support_time.keys()):
+        # special case, the hints file may contain overrides that
+        # are arch-specific (like zsh-doc/armel)
+        if "/" in pkgname:
+            print "%s %s %s" % (
+                pkgname, SUPPORT_TAG, pkg_support_time[pkgname])
+        else:
+            # go over the supported arches, they are divided in
+            # first-class (PRIMARY) and second-class with different
+            # support levels
+            for arch in ubuntu_maintenance.SUPPORTED_ARCHES:
+                # ensure we do not overwrite arch-specific overwrites
+                pkgname_and_arch = "%s/%s" % (pkgname, arch)
+                if pkgname_and_arch in pkg_support_time:
+                    break
+                if arch in ubuntu_maintenance.PRIMARY_ARCHES:
+                    # arch with full LTS support
+                    print "%s %s %s" % (
+                        pkgname_and_arch, SUPPORT_TAG,
+                        pkg_support_time[pkgname])
+                else:
+                    # not a LTS supported architecture, gets only regular
+                    # support_timeframe
+                    print "%s %s %s" % (
+                        pkgname_and_arch, SUPPORT_TAG,
+                        ubuntu_maintenance.SUPPORT_TIMEFRAME[-1][0])

=== added directory 'tests'
=== added file 'tests/__init__.py'
=== added directory 'tests/germinate-test-data'
=== added directory 'tests/germinate-test-data/mock-bin'
=== added file 'tests/germinate-test-data/mock-bin/lockfile'
--- tests/germinate-test-data/mock-bin/lockfile	1970-01-01 00:00:00 +0000
+++ tests/germinate-test-data/mock-bin/lockfile	2014-06-09 13:57:00 +0000
@@ -0,0 +1,8 @@
+#!/bin/sh
+
+# This is a mock "lockfile" command that is used during the test
+# There is no need to have the real lockfile installed (its part
+# of procmail) because there can be no multiple germinate instances
+# while we run the tests
+
+exit 1

=== added directory 'tests/germinate-test-data/mock-lp-root'
=== added directory 'tests/germinate-test-data/mock-lp-root/scripts'
=== added directory 'tests/germinate-test-data/mock-lp-root/scripts/ftpmaster-tools'
=== added file 'tests/germinate-test-data/mock-lp-root/scripts/ftpmaster-tools/lp-query-distro.py'
--- tests/germinate-test-data/mock-lp-root/scripts/ftpmaster-tools/lp-query-distro.py	1970-01-01 00:00:00 +0000
+++ tests/germinate-test-data/mock-lp-root/scripts/ftpmaster-tools/lp-query-distro.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,27 @@
+#!/usr/bin/python
+#
+# This is a mock version of the lp-query-distro.py script that
+# returns static data so that the cron.germinate shell script
+# can be tested.
+
+import sys
+
+
+def error_and_exit():
+    sys.stderr.write("ERROR: I'm a mock, I only support 'supported' as "
+                     "argument\n")
+    sys.exit(1)
+
+
+def main(args):
+    # There is only a very limited subset of arguments that we support,
+    # test for it and error if it looks wrong
+    if len(args) == 2:
+        distro = args[1]
+        if distro == "supported":
+            return "hardy jaunty karmic lucid maverick"
+    error_and_exit()
+
+
+if __name__ == "__main__":
+    print main(sys.argv)

=== added file 'tests/germinate-test-data/mock-lp-root/scripts/generate-extra-overrides.py'
--- tests/germinate-test-data/mock-lp-root/scripts/generate-extra-overrides.py	1970-01-01 00:00:00 +0000
+++ tests/germinate-test-data/mock-lp-root/scripts/generate-extra-overrides.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,5 @@
+#! /usr/bin/python
+#
+# We don't need to run generate-extra-overrides.py when testing
+# maintenance-check.py.  We could, but it would slow down the tests and its
+# output is not interesting here.

=== added symlink 'tests/germinate-test-data/mock-lp-root/scripts/maintenance-check.py'
=== target is u'../../../../scripts/maintenance-check.py'
=== added file 'tests/run'
--- tests/run	1970-01-01 00:00:00 +0000
+++ tests/run	2014-06-09 13:57:00 +0000
@@ -0,0 +1,8 @@
+#! /bin/sh
+set -e
+
+if [ -z "$*" ]; then
+    set -- discover
+fi
+
+PYTHONPATH="$(readlink -f "$(dirname "$0")/../lib")" python -m unittest "$@"

=== added file 'tests/test_cron_germinate.py'
--- tests/test_cron_germinate.py	1970-01-01 00:00:00 +0000
+++ tests/test_cron_germinate.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,226 @@
+# Copyright 2010-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""This is a test for the cron.germinate script."""
+
+__metaclass__ = type
+
+import copy
+import gzip
+import os
+import subprocess
+
+from tests.testing import TestCase
+
+
+class TestCronGerminate(TestCase):
+
+    DISTRO_NAMES = ["platform", "ubuntu", "kubuntu", "netbook"]
+    DISTS = ["hardy", "lucid", "maverick"]
+    DEVELOPMENT_DIST = "natty"
+    COMPONENTS = ["main", "restricted", "universe", "multiverse"]
+    ARCHES = ["i386", "amd64", "armel", "powerpc"]
+    BASEPATH = os.path.abspath(os.path.dirname(__file__))
+    source_root = os.path.normpath(os.path.join(BASEPATH, ".."))
+
+    def setUp(self):
+        super(TestCronGerminate, self).setUp()
+
+        # Setup a temp archive directory and populate it with the right
+        # sub-directories.
+        self.tmpdir = self.makeTemporaryDirectory()
+        self.archive_dir = self.setup_mock_archive_environment()
+        self.ubuntu_misc_dir = os.path.join(self.archive_dir, "ubuntu-misc")
+        self.ubuntu_germinate_dir = os.path.join(
+            self.archive_dir, "ubuntu-germinate")
+        # Create a mock archive environment for all the distros we support and
+        # also include "updates" and "security".
+        for dist in self.DISTS + [self.DEVELOPMENT_DIST]:
+            self.populate_mock_archive_environment(
+                self.archive_dir, self.COMPONENTS, self.ARCHES, dist)
+            for component in ["security", "updates"]:
+                self.populate_mock_archive_environment(
+                    self.archive_dir, self.COMPONENTS, self.ARCHES,
+                    "%s-%s" % (dist, component))
+        # Generate test dummies for maintenance-time.py, if this is set to
+        # "None" instead it will use the network to test against the real
+        # data.
+        self.germinate_output_dir = self.setup_mock_germinate_output()
+
+    def create_directory_if_missing(self, directory):
+        """Create the given directory if it does not exist."""
+        if not os.path.exists(directory):
+            os.makedirs(directory)
+
+    def create_directory_list_if_missing(self, directory_list):
+        """Create the given directories from the list if they don't exist."""
+        for directory in directory_list:
+            self.create_directory_if_missing(directory)
+
+    def create_gzip_file(self, filepath, content=""):
+        """Create a gziped file in the given path with the given content.
+
+        If no content is given a empty file is created.
+        """
+        gz = gzip.GzipFile(filepath, "w")
+        gz.write(content)
+        gz.close()
+
+    def create_file(self, filepath, content=""):
+        """Create a file in the given path with the given content.
+
+        If no content is given a empty file is created.
+        """
+        f = open(filepath, "w")
+        f.write(content)
+        f.close()
+
+    def setup_mock_germinate_output(self):
+        # empty structure files
+        germinate_output_dir = os.path.join(
+            self.tmpdir, "germinate-test-data", "germinate-output")
+        dirs = []
+        for distro_name in self.DISTRO_NAMES:
+            for distro_series in self.DISTS:
+                dirs.append(
+                    os.path.join(
+                        germinate_output_dir,
+                        "%s.%s" % (distro_name, distro_series)))
+        self.create_directory_list_if_missing(dirs)
+        for dir in dirs:
+            self.create_file(os.path.join(dir, "structure"))
+        return germinate_output_dir
+
+    def setup_mock_archive_environment(self):
+        """
+        Creates a mock archive environment and populate it with the
+        subdirectories that germinate will expect.
+        """
+        archive_dir = os.path.join(
+            self.tmpdir, "germinate-test-data", "ubuntu-archive")
+        ubuntu_misc_dir = os.path.join(archive_dir, "ubuntu-misc")
+        ubuntu_germinate_dir = os.path.join(archive_dir, "ubuntu-germinate")
+        ubuntu_dists_dir = os.path.join(archive_dir, "ubuntu", "dists")
+        self.create_directory_list_if_missing([
+                archive_dir,
+                ubuntu_misc_dir,
+                ubuntu_germinate_dir,
+                ubuntu_dists_dir])
+        return archive_dir
+
+    def populate_mock_archive_environment(self, archive_dir, components_list,
+                                          arches_list, current_devel_distro):
+        """
+        Populates a mock archive environment with empty source packages and
+        empty binary packages.
+        """
+        for component in components_list:
+            # Create the environment for the source packages.
+            targetdir = os.path.join(
+                archive_dir,
+                "ubuntu/dists/%s/%s/source" % (
+                    current_devel_distro, component))
+            self.create_directory_if_missing(targetdir)
+            self.create_gzip_file(os.path.join(targetdir, "Sources.gz"))
+
+            # Create the environment for the binary packages.
+            for arch in arches_list:
+                for subpath in ["", "debian-installer"]:
+                    targetdir = os.path.join(
+                        self.archive_dir,
+                        "ubuntu/dists/%s/%s/%s/binary-%s" % (
+                            current_devel_distro, component, subpath, arch))
+                    self.create_directory_if_missing(targetdir)
+                    self.create_gzip_file(os.path.join(
+                            targetdir, "Packages.gz"))
+
+    def create_fake_environment(self, basepath, archive_dir,
+                                germinate_output_dir):
+        """
+        Create a fake process environment based on os.environ that sets
+        TEST_ARCHIVEROOT, TEST_SCRIPTSROOT, and TEST_LAUNCHPADROOT, and
+        modifies PATH to point to the mock lp-bin directory.
+        """
+        fake_environ = copy.copy(os.environ)
+        fake_environ["TEST_ARCHIVEROOT"] = os.path.abspath(
+            os.path.join(archive_dir, "ubuntu"))
+        fake_environ["TEST_SCRIPTSROOT"] = os.path.abspath(
+            os.path.join(basepath, "germinate-test-data/mock-lp-root"))
+        fake_environ["TEST_LAUNCHPADROOT"] = os.path.abspath(
+            os.path.join(basepath, "germinate-test-data/mock-lp-root"))
+        # Set the PATH in the fake environment so that our mock lockfile is
+        # used.
+        fake_environ["PATH"] = "%s:%s" % (
+            os.path.abspath(os.path.join(
+                basepath, "germinate-test-data/mock-bin")),
+            os.environ["PATH"])
+        # test dummies for get-support-timeframe.py, they need to be
+        # in URI format
+        if germinate_output_dir:
+            # redirect base url to the mock environment
+            fake_environ["MAINTENANCE_CHECK_BASE_URL"] = "file://%s" % \
+                germinate_output_dir
+            # point to mock archive root
+            archive_root_url = "file://%s" % os.path.abspath(
+                os.path.join(archive_dir, "ubuntu"))
+            fake_environ["MAINTENANCE_CHECK_ARCHIVE_ROOT"] = archive_root_url
+            # maintenance-check.py expects a format string
+            hints_file_url = (
+                germinate_output_dir + "/platform.%s/SUPPORTED_HINTS")
+            for distro in self.DISTS:
+                open(hints_file_url % distro, "w")
+            fake_environ["MAINTENANCE_CHECK_HINTS_DIR_URL"] = "file://%s" % \
+                os.path.abspath(hints_file_url)
+            # add hints override to test that feature
+            f=open(hints_file_url % "lucid", "a")
+            f.write("linux-image-2.6.32-25-server 5y\n")
+            f.close()
+        return fake_environ
+
+    def test_maintenance_update(self):
+        """
+        Test the maintenance-check.py porition of the soyuz cron.germinate
+        shell script by running it inside a fake environment and ensure that
+        it did update the "Support" override information for apt-ftparchive
+        without destroying/modifying the information that the "germinate"
+        script added to it earlier.
+        """
+        # Write into more-extras.overrides to ensure it is alive after we
+        # mucked around.
+        canary = "abrowser Task mock\n"
+        # Build fake environment based on the real one.
+        fake_environ = self.create_fake_environment(
+            self.BASEPATH, self.archive_dir, self.germinate_output_dir)
+        # Create mock override data files that include the canary string
+        # so that we can test later if it is still there.
+        for dist in self.DISTS:
+            self.create_file(
+                os.path.join(self.ubuntu_misc_dir,
+                             "more-extra.override.%s.main" % dist),
+                canary)
+
+        # Run cron.germinate in the fake environment.
+        cron_germinate_path = os.path.join(
+            self.source_root, "scripts", "cron.germinate")
+        subprocess.call(
+            [cron_germinate_path], env=fake_environ, cwd=self.BASEPATH)
+
+        # And check the output it generated for correctness.
+        for dist in self.DISTS:
+            supported_override_file = os.path.join(
+                self.ubuntu_misc_dir,
+                "more-extra.override.%s.main.supported" % dist)
+            self.assertTrue(os.path.exists(supported_override_file),
+                            "no override file created for '%s'" % dist)
+            main_override_file = os.path.join(
+                self.ubuntu_misc_dir,
+                "more-extra.override.%s.main" % dist)
+            self.assertIn(canary, open(main_override_file).read())
+
+        # Check here if we got the data from maintenance-check.py that
+        # we expected. This is a kernel name from lucid-updates and it
+        # will be valid for 5 years.
+        needle = "linux-image-2.6.32-25-server/i386 Supported 5y"
+        lucid_supported_override_file = os.path.join(
+            self.ubuntu_misc_dir, "more-extra.override.lucid.main")
+        self.assertIn(needle, open(lucid_supported_override_file).read())

=== added file 'tests/test_generate_extra_overrides.py'
--- tests/test_generate_extra_overrides.py	1970-01-01 00:00:00 +0000
+++ tests/test_generate_extra_overrides.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,805 @@
+# Copyright 2011-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Test for the `generate-extra-overrides` script."""
+
+__metaclass__ = type
+
+from collections import defaultdict
+from functools import partial
+import gzip
+import logging
+from optparse import OptionValueError
+import os
+import tempfile
+try:
+    from unittest import mock
+except ImportError:
+    import mock
+
+from germinate import (
+    archive,
+    germinator,
+    seeds,
+    )
+
+from scripts.generate_extra_overrides import (
+    AtomicFile,
+    file_exists,
+    GenerateExtraOverrides,
+    ScriptFailure,
+    )
+from tests.testing import (
+    ensure_directory_exists,
+    factory,
+    file_contents,
+    open_for_writing,
+    run_script,
+    TestCase,
+    write_file,
+    )
+
+
+class TestAtomicFile(TestCase):
+    """Tests for the AtomicFile helper class."""
+
+    def test_atomic_file_creates_file(self):
+        # AtomicFile creates the named file with the requested contents.
+        self.useTempDir()
+        filename = factory.getUniqueString()
+        text = factory.getUniqueString()
+        with AtomicFile(filename) as test:
+            test.write(text)
+        self.assertEqual(text, file_contents(filename))
+
+    def test_atomic_file_removes_dot_new(self):
+        # AtomicFile does not leave .new files lying around.
+        self.useTempDir()
+        filename = factory.getUniqueString()
+        with AtomicFile(filename):
+            pass
+        self.assertFalse(file_exists("%s.new" % filename))
+
+
+class IndexStanzaFields:
+    """Store and format ordered Index Stanza fields."""
+
+    def __init__(self):
+        self._names_lower = set()
+        self.fields = []
+
+    def append(self, name, value):
+        """Append an (field, value) tuple to the internal list.
+
+        Then we can use the FIFO-like behaviour in makeOutput().
+        """
+        if name.lower() in self._names_lower:
+            return
+        self._names_lower.add(name.lower())
+        self.fields.append((name, value))
+
+    def extend(self, entries):
+        """Extend the internal list with the key-value pairs in entries.
+        """
+        for name, value in entries:
+            self.append(name, value)
+
+    def makeOutput(self):
+        """Return a line-by-line aggregation of appended fields.
+
+        Empty fields values will cause the exclusion of the field.
+        The output order will preserve the insertion order, FIFO.
+        """
+        output_lines = []
+        for name, value in self.fields:
+            if not value:
+                continue
+
+            # Do not add separation space for the special file list fields.
+            if name not in ('Files', 'Checksums-Sha1', 'Checksums-Sha256'):
+                value = ' %s' % value
+
+            output_lines.append('%s:%s' % (name, value))
+
+        return '\n'.join(output_lines)
+
+
+class MockArchivePublisherBase(mock.MagicMock):
+
+    def getIndexStanza(self):
+        fields = self.buildIndexStanzaFields()
+        return fields.makeOutput()
+
+
+class MockSourcePackagePublishingHistory(MockArchivePublisherBase):
+    """A mock source package publishing history.
+
+    This is a crude amalgam of SourcePackageRelease and
+    SourcePackagePublishingHistory, but it'll do for us.
+    """
+
+    def __init__(self, sourcepackagename=None):
+        super(MockSourcePackagePublishingHistory, self).__init__()
+        if sourcepackagename is None:
+            sourcepackagename = factory.getUniqueString()
+        self.sourcepackagename = sourcepackagename
+        self.binaries = []
+        self.version = unicode(factory.getUniqueInteger()) + "version"
+        self.section = factory.getUniqueString(prefix="section")
+        self.dsc_maintainer_rfc822 = "%s <%s>" % (
+            factory.getUniqueString(), factory.getUniqueEmailAddress())
+        self.architecturehintlist = "all"
+        self.dsc_format = "1.0"
+
+    @property
+    def dsc_binaries(self):
+        return ", ".join(self.binaries)
+
+    def buildIndexStanzaFields(self):
+        fields = IndexStanzaFields()
+        fields.append("Package", self.sourcepackagename)
+        fields.append("Binary", self.dsc_binaries)
+        fields.append("Version", self.version)
+        fields.append("Section", self.section)
+        fields.append("Maintainer", self.dsc_maintainer_rfc822)
+        fields.append("Architecture", self.architecturehintlist)
+        fields.append("Format", self.dsc_format)
+        return fields
+
+
+class MockBinaryPackagePublishingHistory(MockArchivePublisherBase):
+    """A mock binary package publishing history.
+
+    This is a crude amalgam of BinaryPackageRelease and
+    BinaryPackagePublishingHistory, but it'll do for us.
+    """
+
+    def __init__(self, spph, das, binarypackagename=None, depends=None):
+        super(MockBinaryPackagePublishingHistory, self).__init__()
+        if binarypackagename is None:
+            binarypackagename = factory.getUniqueString()
+        self.spph = spph
+        self.das = das
+        self.binarypackagename = binarypackagename
+        self.priority = "optional"
+        self.depends = depends
+
+    def buildIndexStanzaFields(self):
+        fields = IndexStanzaFields()
+        fields.append("Package", self.binarypackagename)
+        fields.append("Source", self.spph.sourcepackagename)
+        fields.append("Priority", self.priority)
+        fields.append("Section", self.spph.section)
+        fields.append("Maintainer", self.spph.dsc_maintainer_rfc822)
+        fields.append("Architecture", self.das.architecture_tag)
+        fields.append("Version", self.spph.version)
+        fields.append("Depends", self.depends)
+        return fields
+
+
+class MockDistroArchSeries(mock.MagicMock):
+    def __init__(self, distroseries, architecture_tag=None):
+        super(MockDistroArchSeries, self).__init__()
+        if architecture_tag is None:
+            architecture_tag = factory.getUniqueString(prefix="arch")
+        self.distroseries = distroseries
+        self.architecture_tag = architecture_tag
+        self.test_binaries = defaultdict(list)
+
+
+class MockDistroSeries(mock.MagicMock):
+    def __init__(self, distribution, status="Active Development"):
+        super(MockDistroSeries, self).__init__()
+        self.name = factory.getUniqueString(prefix="distroseries")
+        self.distribution = distribution
+        self.component_names = []
+        self.status = status
+        self.architectures = []
+        self.test_sources = defaultdict(list)
+
+    def makeDistroArchSeries(self, enabled=True, *args, **kwargs):
+        das = MockDistroArchSeries(distroseries=self, *args, **kwargs)
+        if enabled:
+            self.architectures.append(das)
+        return das
+
+
+class MockDistribution(mock.MagicMock):
+    def __init__(self, name):
+        super(MockDistribution, self).__init__()
+        self.name = name
+        self.series = []
+
+    def makeDistroSeries(self, *args, **kwargs):
+        series = MockDistroSeries(distribution=self, *args, **kwargs)
+        self.series.append(series)
+        return series
+
+
+class MockLaunchpad(mock.MagicMock):
+    def __init__(self):
+        super(MockLaunchpad, self).__init__(name="Launchpad")
+        self.distributions = {}
+
+    def makeDistribution(self, name=None):
+        if name is None:
+            name = factory.getUniqueString()
+        distribution = MockDistribution(name)
+        self.distributions[name] = distribution
+        return distribution
+
+
+class TestGenerateExtraOverrides(TestCase):
+    """Tests for the actual `GenerateExtraOverrides` script."""
+
+    def setUp(self):
+        super(TestGenerateExtraOverrides, self).setUp()
+        self.seeddir = self.makeTemporaryDirectory()
+        self.launchpad = MockLaunchpad()
+        # XXX cjwatson 2011-12-06 bug=694140: Make sure germinate doesn't
+        # lose its loggers between tests, due to Launchpad's messing with
+        # global log state.
+        archive._logger = logging.getLogger("germinate.archive")
+        germinator._logger = logging.getLogger("germinate.germinator")
+        seeds._logger = logging.getLogger("germinate.seeds")
+
+    def assertFilesEqual(self, expected_path, observed_path):
+        self.assertEqual(
+            file_contents(expected_path), file_contents(observed_path))
+
+    def makeDistro(self):
+        """Create a distribution for testing.
+
+        The distribution will have a root directory set up, which will
+        be cleaned up after the test.  It will have an attached archive.
+        """
+        publish_root_dir = self.makeTemporaryDirectory()
+        os.environ["ARCHIVEROOTS"] = publish_root_dir
+        return self.launchpad.makeDistribution()
+
+    def makeScript(self, distribution, run_setup=True, extra_args=None):
+        """Create a script for testing."""
+        test_args = []
+        if distribution is not None:
+            test_args.extend(["-d", distribution.name])
+        if extra_args is not None:
+            test_args.extend(extra_args)
+        script = GenerateExtraOverrides(test_args=test_args)
+        for handler in list(script.logger.handlers):
+            script.logger.removeHandler(handler)
+        script.logger.addHandler(logging.NullHandler())
+        script.login = lambda: self.launchpad
+        if distribution is not None and run_setup:
+            script.setUp()
+        else:
+            script.distribution = distribution
+        return script
+
+    def setUpDistroAndScript(self, series_statuses=["Active Development"],
+                             **kwargs):
+        """Helper wrapping distro and script setup."""
+        self.distro = self.makeDistro()
+        self.distroseries = [
+            self.distro.makeDistroSeries(status=status)
+            for status in series_statuses]
+        self.script = self.makeScript(self.distro, **kwargs)
+
+    def setUpComponent(self, component=None):
+        """Create a component and attach it to all distroseries."""
+        if component is None:
+            component = factory.getUniqueString()
+        for distroseries in self.distroseries:
+            distroseries.component_names.append(component)
+        return component
+
+    def makePackage(self, component, dases, **kwargs):
+        """Create a published source and binary package for testing."""
+        package_name = factory.getUniqueString()
+        spph = MockSourcePackagePublishingHistory(
+            sourcepackagename=package_name)
+        dases[0].distroseries.test_sources[component].append(spph)
+        for das in dases:
+            bpph = MockBinaryPackagePublishingHistory(
+                spph, das, binarypackagename=package_name, **kwargs)
+            das.test_binaries[component].append(bpph)
+        return package_name
+
+    def makeIndexFiles(self, script, distroseries):
+        """Create a limited subset of index files for testing."""
+        for component in distroseries.component_names:
+            sources_path = os.path.join(
+                script.archiveroot, "dists", distroseries.name, component,
+                "source", "Sources.gz")
+            ensure_directory_exists(os.path.dirname(sources_path))
+            sources_index = gzip.GzipFile(sources_path, "wb")
+            for spp in distroseries.test_sources[component]:
+                stanza = spp.getIndexStanza().encode("utf-8") + "\n\n"
+                sources_index.write(stanza)
+            sources_index.close()
+
+            for arch in distroseries.architectures:
+                packages_path = os.path.join(
+                    script.archiveroot, "dists", distroseries.name, component,
+                    "binary-%s" % arch.architecture_tag, "Packages.gz")
+                ensure_directory_exists(os.path.dirname(packages_path))
+                packages_index = gzip.GzipFile(packages_path, "wb")
+                for bpp in arch.test_binaries[component]:
+                    stanza = bpp.getIndexStanza().encode("utf-8") + "\n\n"
+                    packages_index.write(stanza)
+                packages_index.close()
+
+    def composeSeedPath(self, flavour, series_name, seed_name):
+        return os.path.join(
+            self.seeddir, "%s.%s" % (flavour, series_name), seed_name)
+
+    def makeSeedStructure(self, flavour, series_name, seed_names,
+                          seed_inherit={}):
+        """Create a simple seed structure file."""
+        structure_path = self.composeSeedPath(
+            flavour, series_name, "STRUCTURE")
+        with open_for_writing(structure_path, "w") as structure:
+            for seed_name in seed_names:
+                inherit = seed_inherit.get(seed_name, [])
+                line = "%s: %s" % (seed_name, " ".join(inherit))
+                print >>structure, line.strip()
+
+    def makeSeed(self, flavour, series_name, seed_name, entries,
+                 headers=None):
+        """Create a simple seed file."""
+        seed_path = self.composeSeedPath(flavour, series_name, seed_name)
+        with open_for_writing(seed_path, "w") as seed:
+            if headers is not None:
+                for header in headers:
+                    print >>seed, header
+                print >>seed
+            for entry in entries:
+                print >>seed, " * %s" % entry
+
+    def getTaskNameFromSeed(self, script, flavour, series_name, seed,
+                            primary_flavour):
+        """Use script to parse a seed and return its task name."""
+        seed_path = self.composeSeedPath(flavour, series_name, seed)
+        with open(seed_path) as seed_text:
+            task_headers = script.parseTaskHeaders(seed_text)
+        return script.getTaskName(
+            task_headers, flavour, seed, primary_flavour)
+
+    def getTaskSeedsFromSeed(self, script, flavour, series_name, seed):
+        """Use script to parse a seed and return its task seed list."""
+        seed_path = self.composeSeedPath(flavour, series_name, seed)
+        with open(seed_path) as seed_text:
+            task_headers = script.parseTaskHeaders(seed_text)
+        return script.getTaskSeeds(task_headers, seed)
+
+    def test_name_is_consistent(self):
+        # Script instances for the same distro get the same name.
+        distro = self.launchpad.makeDistribution()
+        self.assertEqual(
+            GenerateExtraOverrides(test_args=["-d", distro.name]).name,
+            GenerateExtraOverrides(test_args=["-d", distro.name]).name)
+
+    def test_name_is_unique_for_each_distro(self):
+        # Script instances for different distros get different names.
+        self.assertNotEqual(
+            GenerateExtraOverrides(
+                test_args=["-d", self.launchpad.makeDistribution().name]).name,
+            GenerateExtraOverrides(
+                test_args=["-d", self.launchpad.makeDistribution().name]).name)
+
+    def test_requires_distro(self):
+        # The --distribution or -d argument is mandatory.
+        script = self.makeScript(None)
+        self.assertRaises(OptionValueError, script.processOptions)
+
+    def test_requires_real_distro(self):
+        # An incorrect distribution name is flagged as an invalid option
+        # value.
+        script = self.makeScript(
+            None, extra_args=["-d", factory.getUniqueString()])
+        self.assertRaises(OptionValueError, script.processOptions)
+
+    def test_looks_up_distro(self):
+        # The script looks up and keeps the distribution named on the
+        # command line.
+        self.setUpDistroAndScript()
+        self.assertEqual(self.distro, self.script.distribution)
+
+    def test_prefers_development_distro_series(self):
+        # The script prefers a DEVELOPMENT series for the named
+        # distribution over CURRENT and SUPPORTED series.
+        self.setUpDistroAndScript(
+            ["Supported", "Current Stable Release", "Active Development"])
+        self.assertEqual([self.distroseries[2]], self.script.series)
+
+    def test_permits_frozen_distro_series(self):
+        # If there is no DEVELOPMENT series, a FROZEN one will do.
+        self.setUpDistroAndScript(
+            ["Supported", "Current Stable Release", "Pre-release Freeze"])
+        self.assertEqual([self.distroseries[2]], self.script.series)
+
+    def test_requires_development_frozen_distro_series(self):
+        # If there is no DEVELOPMENT or FROZEN series, the script fails.
+        self.setUpDistroAndScript(
+            ["Supported", "Current Stable Release"], run_setup=False)
+        self.assertRaises(ScriptFailure, self.script.processOptions)
+
+    def test_multiple_development_frozen_distro_series(self):
+        # If there are multiple DEVELOPMENT or FROZEN series, they are all
+        # used.
+        self.setUpDistroAndScript([
+            "Active Development", "Active Development",
+            "Pre-release Freeze", "Pre-release Freeze",
+            ])
+        self.assertCountEqual(self.distroseries, self.script.series)
+
+    def test_components_exclude_partner(self):
+        # If a 'partner' component exists, it is excluded.
+        self.setUpDistroAndScript()
+        self.setUpComponent(component="main")
+        self.setUpComponent(component="partner")
+        self.assertEqual(1, len(self.script.series))
+        self.assertEqual(
+            ["main"], self.script.getComponents(self.script.series[0]))
+
+    def test_compose_output_path_in_germinateroot(self):
+        # Output files are written to the correct locations under
+        # germinateroot.
+        self.setUpDistroAndScript()
+        flavour = factory.getUniqueString()
+        arch = factory.getUniqueString()
+        base = factory.getUniqueString()
+        output = self.script.composeOutputPath(
+            flavour, self.distroseries[0].name, arch, base)
+        self.assertEqual(
+            "%s/%s_%s_%s_%s" % (
+                self.script.germinateroot, base, flavour,
+                self.distroseries[0].name, arch),
+            output)
+
+    def test_make_seed_structures_missing_seeds(self):
+        # makeSeedStructures ignores missing seeds.
+        self.setUpDistroAndScript()
+        series_name = self.distroseries[0].name
+        flavour = factory.getUniqueString()
+
+        structures = self.script.makeSeedStructures(
+            series_name, [flavour], seed_bases=["file://%s" % self.seeddir])
+        self.assertEqual({}, structures)
+
+    def test_make_seed_structures_empty_seed_structure(self):
+        # makeSeedStructures ignores an empty seed structure.
+        self.setUpDistroAndScript()
+        series_name = self.distroseries[0].name
+        flavour = factory.getUniqueString()
+        self.makeSeedStructure(flavour, series_name, [])
+
+        structures = self.script.makeSeedStructures(
+            series_name, [flavour], seed_bases=["file://%s" % self.seeddir])
+        self.assertEqual({}, structures)
+
+    def test_make_seed_structures_valid_seeds(self):
+        # makeSeedStructures reads valid seeds successfully.
+        self.setUpDistroAndScript()
+        series_name = self.distroseries[0].name
+        flavour = factory.getUniqueString()
+        seed = factory.getUniqueString()
+        self.makeSeedStructure(flavour, series_name, [seed])
+        self.makeSeed(flavour, series_name, seed, [])
+
+        structures = self.script.makeSeedStructures(
+            series_name, [flavour], seed_bases=["file://%s" % self.seeddir])
+        self.assertIn(flavour, structures)
+
+    def fetchGerminatedOverrides(self, script, distroseries, arch, flavours):
+        """Helper to call script.germinateArch and return overrides."""
+        structures = script.makeSeedStructures(
+            distroseries.name, flavours,
+            seed_bases=["file://%s" % self.seeddir])
+
+        override_fd, override_path = tempfile.mkstemp()
+        with os.fdopen(override_fd, "w") as override_file:
+            script.germinateArch(
+                override_file, distroseries.name,
+                script.getComponents(distroseries), arch, flavours,
+                structures)
+        return file_contents(override_path).splitlines()
+
+    def test_germinate_output(self):
+        # A single call to germinateArch produces output for all flavours on
+        # one architecture.
+        self.setUpDistroAndScript()
+        series_name = self.distroseries[0].name
+        component = self.setUpComponent()
+        das = self.distroseries[0].makeDistroArchSeries()
+        arch = das.architecture_tag
+        one = self.makePackage(component, [das])
+        two = self.makePackage(component, [das])
+        self.makeIndexFiles(self.script, self.distroseries[0])
+
+        flavour_one = factory.getUniqueString()
+        flavour_two = factory.getUniqueString()
+        seed = factory.getUniqueString()
+        self.makeSeedStructure(flavour_one, series_name, [seed])
+        self.makeSeed(flavour_one, series_name, seed, [one])
+        self.makeSeedStructure(flavour_two, series_name, [seed])
+        self.makeSeed(flavour_two, series_name, seed, [two])
+
+        overrides = self.fetchGerminatedOverrides(
+            self.script, self.distroseries[0], arch,
+            [flavour_one, flavour_two])
+        self.assertEqual([], overrides)
+
+        seed_dir_one = os.path.join(
+            self.seeddir, "%s.%s" % (flavour_one, series_name))
+        self.assertFilesEqual(
+            os.path.join(seed_dir_one, "STRUCTURE"),
+            self.script.composeOutputPath(
+                flavour_one, series_name, arch, "structure"))
+        self.assertTrue(file_exists(self.script.composeOutputPath(
+            flavour_one, series_name, arch, "all")))
+        self.assertTrue(file_exists(self.script.composeOutputPath(
+            flavour_one, series_name, arch, "all.sources")))
+        self.assertTrue(file_exists(self.script.composeOutputPath(
+            flavour_one, series_name, arch, seed)))
+
+        seed_dir_two = os.path.join(
+            self.seeddir, "%s.%s" % (flavour_two, series_name))
+        self.assertFilesEqual(
+            os.path.join(seed_dir_two, "STRUCTURE"),
+            self.script.composeOutputPath(
+                flavour_two, series_name, arch, "structure"))
+        self.assertTrue(file_exists(self.script.composeOutputPath(
+            flavour_two, series_name, arch, "all")))
+        self.assertTrue(file_exists(self.script.composeOutputPath(
+            flavour_two, series_name, arch, "all.sources")))
+        self.assertTrue(file_exists(self.script.composeOutputPath(
+            flavour_two, series_name, arch, seed)))
+
+    def test_germinate_output_task(self):
+        # germinateArch produces Task extra overrides.
+        self.setUpDistroAndScript()
+        series_name = self.distroseries[0].name
+        component = self.setUpComponent()
+        das = self.distroseries[0].makeDistroArchSeries()
+        arch = das.architecture_tag
+        one = self.makePackage(component, [das])
+        two = self.makePackage(component, [das], depends=one)
+        three = self.makePackage(component, [das])
+        self.makePackage(component, [das])
+        self.makeIndexFiles(self.script, self.distroseries[0])
+
+        flavour = factory.getUniqueString()
+        seed_one = factory.getUniqueString()
+        seed_two = factory.getUniqueString()
+        self.makeSeedStructure(flavour, series_name, [seed_one, seed_two])
+        self.makeSeed(
+            flavour, series_name, seed_one, [two],
+            headers=["Task-Description: one"])
+        self.makeSeed(
+            flavour, series_name, seed_two, [three],
+            headers=["Task-Description: two"])
+
+        overrides = self.fetchGerminatedOverrides(
+            self.script, self.distroseries[0], arch, [flavour])
+        expected_overrides = [
+            "%s/%s  Task  %s" % (one, arch, seed_one),
+            "%s/%s  Task  %s" % (two, arch, seed_one),
+            "%s/%s  Task  %s" % (three, arch, seed_two),
+            ]
+        self.assertCountEqual(expected_overrides, overrides)
+
+    def test_task_name(self):
+        # The Task-Name field is honoured.
+        series_name = factory.getUniqueString()
+        package = factory.getUniqueString()
+        script = self.makeScript(None)
+
+        flavour = factory.getUniqueString()
+        seed = factory.getUniqueString()
+        task = factory.getUniqueString()
+        self.makeSeed(
+            flavour, series_name, seed, [package],
+            headers=["Task-Name: %s" % task])
+
+        observed_task = self.getTaskNameFromSeed(
+            script, flavour, series_name, seed, True)
+        self.assertEqual(task, observed_task)
+
+    def test_task_per_derivative(self):
+        # The Task-Per-Derivative field is honoured.
+        series_name = factory.getUniqueString()
+        package = factory.getUniqueString()
+        script = self.makeScript(None)
+
+        flavour_one = factory.getUniqueString()
+        flavour_two = factory.getUniqueString()
+        seed_one = factory.getUniqueString()
+        seed_two = factory.getUniqueString()
+        self.makeSeed(
+            flavour_one, series_name, seed_one, [package],
+            headers=["Task-Description: one"])
+        self.makeSeed(
+            flavour_one, series_name, seed_two, [package],
+            headers=["Task-Per-Derivative: 1"])
+        self.makeSeed(
+            flavour_two, series_name, seed_one, [package],
+            headers=["Task-Description: one"])
+        self.makeSeed(
+            flavour_two, series_name, seed_two, [package],
+            headers=["Task-Per-Derivative: 1"])
+
+        observed_task_one_one = self.getTaskNameFromSeed(
+            script, flavour_one, series_name, seed_one, True)
+        observed_task_one_two = self.getTaskNameFromSeed(
+            script, flavour_one, series_name, seed_two, True)
+        observed_task_two_one = self.getTaskNameFromSeed(
+            script, flavour_two, series_name, seed_one, False)
+        observed_task_two_two = self.getTaskNameFromSeed(
+            script, flavour_two, series_name, seed_two, False)
+
+        # seed_one is not per-derivative, so it is honoured only for
+        # flavour_one and has a global name.
+        self.assertEqual(seed_one, observed_task_one_one)
+        self.assertIsNone(observed_task_two_one)
+
+        # seed_two is per-derivative, so it is honoured for both flavours
+        # and has the flavour name prefixed.
+        self.assertEqual(
+            "%s-%s" % (flavour_one, seed_two), observed_task_one_two)
+        self.assertEqual(
+            "%s-%s" % (flavour_two, seed_two), observed_task_two_two)
+
+    def test_task_seeds(self):
+        # The Task-Seeds field is honoured.
+        series_name = factory.getUniqueString()
+        one = factory.getUniqueString()
+        two = factory.getUniqueString()
+        script = self.makeScript(None)
+
+        flavour = factory.getUniqueString()
+        seed_one = factory.getUniqueString()
+        seed_two = factory.getUniqueString()
+        self.makeSeed(flavour, series_name, seed_one, [one])
+        self.makeSeed(
+            flavour, series_name, seed_two, [two],
+            headers=["Task-Seeds: %s" % seed_one])
+
+        task_seeds = self.getTaskSeedsFromSeed(
+            script, flavour, series_name, seed_two)
+        self.assertCountEqual([seed_one, seed_two], task_seeds)
+
+    def test_germinate_output_build_essential(self):
+        # germinateArch produces Build-Essential extra overrides.
+        self.setUpDistroAndScript()
+        series_name = self.distroseries[0].name
+        component = self.setUpComponent()
+        das = self.distroseries[0].makeDistroArchSeries()
+        arch = das.architecture_tag
+        package = self.makePackage(component, [das])
+        self.makeIndexFiles(self.script, self.distroseries[0])
+
+        flavour = factory.getUniqueString()
+        seed = "build-essential"
+        self.makeSeedStructure(flavour, series_name, [seed])
+        self.makeSeed(flavour, series_name, seed, [package])
+
+        overrides = self.fetchGerminatedOverrides(
+            self.script, self.distroseries[0], arch, [flavour])
+        self.assertCountEqual(
+            ["%s/%s  Build-Essential  yes" % (package, arch)], overrides)
+
+    def test_removes_only_stale_files(self):
+        # removeStaleOutputs removes only stale germinate output files.
+        self.setUpDistroAndScript()
+        series_name = self.distroseries[0].name
+        seed_old_file = "old_flavour_%s_i386" % series_name
+        seed_new_file = "new_flavour_%s_i386" % series_name
+        other_file = "other-file"
+        output = partial(os.path.join, self.script.germinateroot)
+        for base in (seed_old_file, seed_new_file, other_file):
+            write_file(output(base), "")
+        self.script.removeStaleOutputs(series_name, set([seed_new_file]))
+        self.assertFalse(os.path.exists(output(seed_old_file)))
+        self.assertTrue(os.path.exists(output(seed_new_file)))
+        self.assertTrue(os.path.exists(output(other_file)))
+
+    def test_process_missing_seeds(self):
+        # The script ignores series with no seed structures.
+        flavour = factory.getUniqueString()
+        self.setUpDistroAndScript(
+            ["Active Development", "Active Development"], extra_args=[flavour])
+        self.setUpComponent()
+        self.distroseries[0].makeDistroArchSeries()
+        self.distroseries[1].makeDistroArchSeries()
+        self.makeIndexFiles(self.script, self.distroseries[1])
+        seed = factory.getUniqueString()
+        self.makeSeedStructure(flavour, self.distroseries[1].name, [seed])
+        self.makeSeed(flavour, self.distroseries[1].name, seed, [])
+
+        self.script.process(seed_bases=["file://%s" % self.seeddir])
+        self.assertFalse(os.path.exists(os.path.join(
+            self.script.miscroot,
+            "more-extra.override.%s.main" % self.distroseries[0].name)))
+        self.assertTrue(os.path.exists(os.path.join(
+            self.script.miscroot,
+            "more-extra.override.%s.main" % self.distroseries[1].name)))
+
+    def test_process_removes_only_stale_files(self):
+        # The script removes only stale germinate output files.
+        flavour = factory.getUniqueString()
+        self.setUpDistroAndScript(extra_args=[flavour])
+        series_name = self.distroseries[0].name
+        self.setUpComponent()
+        das = self.distroseries[0].makeDistroArchSeries()
+        arch = das.architecture_tag
+        self.makeIndexFiles(self.script, self.distroseries[0])
+
+        seed_old = factory.getUniqueString()
+        seed_new = factory.getUniqueString()
+        self.makeSeedStructure(flavour, series_name, [seed_old])
+        self.makeSeed(flavour, series_name, seed_old, [])
+        self.script.process(seed_bases=["file://%s" % self.seeddir])
+        output = partial(
+            self.script.composeOutputPath, flavour, series_name, arch)
+        self.assertTrue(os.path.exists(output(seed_old)))
+        self.makeSeedStructure(flavour, series_name, [seed_new])
+        self.makeSeed(flavour, series_name, seed_new, [])
+        self.script.process(seed_bases=["file://%s" % self.seeddir])
+        self.assertTrue(os.path.exists(os.path.join(self.script.log_file)))
+        self.assertTrue(os.path.exists(output("structure")))
+        self.assertTrue(os.path.exists(output("all")))
+        self.assertTrue(os.path.exists(output("all.sources")))
+        self.assertTrue(os.path.exists(output(seed_new)))
+        self.assertFalse(os.path.exists(output(seed_old)))
+
+    def test_process_skips_disabled_distroarchseries(self):
+        # The script does not generate overrides for disabled DistroArchSeries.
+        flavour = factory.getUniqueString()
+        self.setUpDistroAndScript(extra_args=[flavour])
+        das = self.distroseries[0].makeDistroArchSeries()
+        self.distroseries[0].makeDistroArchSeries(enabled=False)
+        self.script.generateExtraOverrides = mock.MagicMock()
+        self.script.process()
+        self.assertEqual(1, self.script.generateExtraOverrides.call_count)
+        self.assertEqual(
+            [das.architecture_tag],
+            self.script.generateExtraOverrides.call_args[0][2])
+
+    def test_main(self):
+        # If run end-to-end, the script generates override files containing
+        # output for all architectures, and sends germinate's log output to
+        # a file.
+        flavour = factory.getUniqueString()
+        self.setUpDistroAndScript(extra_args=[flavour])
+        series_name = self.distroseries[0].name
+        component = self.setUpComponent()
+        das_one = self.distroseries[0].makeDistroArchSeries()
+        das_two = self.distroseries[0].makeDistroArchSeries()
+        package = self.makePackage(component, [das_one, das_two])
+        self.makeIndexFiles(self.script, self.distroseries[0])
+
+        seed = factory.getUniqueString()
+        self.makeSeedStructure(flavour, series_name, [seed])
+        self.makeSeed(
+            flavour, series_name, seed, [package],
+            headers=["Task-Description: task"])
+
+        self.script.process(seed_bases=["file://%s" % self.seeddir])
+        override_path = os.path.join(
+            self.script.miscroot, "more-extra.override.%s.main" % series_name)
+        expected_overrides = [
+            "%s/%s  Task  %s" % (package, das_one.architecture_tag, seed),
+            "%s/%s  Task  %s" % (package, das_two.architecture_tag, seed),
+            ]
+        self.assertCountEqual(
+            expected_overrides, file_contents(override_path).splitlines())
+
+        log_file = os.path.join(self.script.germinateroot, "germinate.output")
+        self.assertIn("Downloading file://", file_contents(log_file))
+
+    def test_run_script_help(self):
+        # The script will run stand-alone and generate help output.
+        retval, out, err = run_script(
+            "scripts/generate-extra-overrides.py", ["-h"])
+        self.assertEqual(0, retval)
+        self.assertEqual("", err)

=== added file 'tests/testing.py'
--- tests/testing.py	1970-01-01 00:00:00 +0000
+++ tests/testing.py	2014-06-09 13:57:00 +0000
@@ -0,0 +1,174 @@
+# Copyright 2011-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Test utilities.
+
+Many of these are taken more or less directly from Launchpad.
+"""
+
+__metaclass__ = type
+
+__all__ = [
+    "ensure_directory_exists",
+    "factory",
+    "file_contents",
+    "open_for_writing",
+    "run_script",
+    "TestCase",
+    "write_file",
+    ]
+
+import errno
+from itertools import count
+import logging
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+import unittest
+
+
+def ensure_directory_exists(directory, mode=0777):
+    """Create 'directory' if it doesn't exist.
+
+    :return: True if the directory had to be created, False otherwise.
+    """
+    try:
+        os.makedirs(directory, mode=mode)
+    except OSError as e:
+        if e.errno == errno.EEXIST:
+            return False
+        raise
+    return True
+
+
+def open_for_writing(filename, mode, dirmode=0777):
+    """Open 'filename' for writing, creating directories if necessary.
+
+    :param filename: The path of the file to open.
+    :param mode: The mode to open the filename with. Should be 'w', 'a' or
+        something similar. See ``open`` for more details. If you pass in
+        a read-only mode (e.g. 'r'), then we'll just accept that and return
+        a read-only file-like object.
+    :param dirmode: The mode to use to create directories, if necessary.
+    :return: A file-like object that can be used to write to 'filename'.
+    """
+    try:
+        return open(filename, mode)
+    except IOError as e:
+        if e.errno == errno.ENOENT:
+            os.makedirs(os.path.dirname(filename), mode=dirmode)
+            return open(filename, mode)
+
+
+def write_file(path, content):
+    with open_for_writing(path, 'w') as f:
+        f.write(content)
+
+
+def run_script(script_relpath, args, expect_returncode=0):
+    """Run a script for testing purposes.
+
+    :param script_relpath: The relative path to the script, from the tree
+        root.
+    :param args: Arguments to provide to the script.
+    :param expect_returncode: The return code expected.  If a different value
+        is returned, and exception will be raised.
+    """
+    script = os.path.join(sys.path[0], script_relpath)
+    args = [script] + args
+    process = subprocess.Popen(
+        args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    stdout, stderr = process.communicate()
+    if process.returncode != expect_returncode:
+        raise AssertionError('Failed:\n%s\n%s' % (stdout, stderr))
+    return (process.returncode, stdout, stderr)
+
+
+def file_contents(path):
+    """Return the contents of the file at path."""
+    with open(path) as handle:
+        return handle.read()
+
+
+class ObjectFactory:
+
+    _unique_int_counter = count(100000)
+
+    def getUniqueEmailAddress(self):
+        return "[e-mail]" % self.getUniqueString("email")
+
+    def getUniqueInteger(self):
+        return next(self._unique_int_counter)
+
+    def getUniqueString(self, prefix=None):
+        if prefix is None:
+            prefix = "unique"
+        return "%s-%s" % (prefix, self.getUniqueInteger())
+
+
+factory = ObjectFactory()
+
+
+class TestCase(unittest.TestCase):
+
+    def setUp(self):
+        super(TestCase, self).setUp()
+        self.save_env = dict(os.environ)
+
+    def makeTemporaryDirectory(self):
+        """Create a temporary directory, and return its path."""
+        temp_dir = tempfile.mkdtemp()
+        self.addCleanup(shutil.rmtree, temp_dir)
+        return temp_dir
+
+    def useTempDir(self):
+        """Use a temporary directory for this test."""
+        tempdir = self.makeTemporaryDirectory()
+        cwd = os.getcwd()
+        os.chdir(tempdir)
+        self.addCleanup(os.chdir, cwd)
+        return tempdir
+
+    def resetEnvironment(self):
+        for key in set(os.environ.keys()) - set(self.save_env.keys()):
+            del os.environ[key]
+        for key, value in os.environ.items():
+            if value != self.save_env[key]:
+                os.environ[key] = self.save_env[key]
+        for key in set(self.save_env.keys()) - set(os.environ.keys()):
+            os.environ[key] = self.save_env[key]
+
+    def resetLogging(self):
+        # Remove all handlers from non-root loggers, and remove the loggers
+        # too.
+        loggerDict = logging.Logger.manager.loggerDict
+        for name, logger in list(loggerDict.items()):
+            if not isinstance(logger, logging.PlaceHolder):
+                for handler in list(logger.handlers):
+                    logger.removeHandler(handler)
+            del loggerDict[name]
+
+        # Remove all handlers from the root logger
+        root = logging.getLogger('')
+        for handler in root.handlers:
+            root.removeHandler(handler)
+
+        # Set the root logger's log level back to the default level:
+        # WARNING.
+        root.setLevel(logging.WARNING)
+
+        # Clean out the guts of the logging module.  We don't want handlers
+        # that have already been closed hanging around for the atexit
+        # handler to barf on, for example.
+        del logging._handlerList[:]
+        logging._handlers.clear()
+
+    def tearDown(self):
+        self.resetEnvironment()
+        self.resetLogging()
+
+    # Monkey-patch for Python 2/3 compatibility.
+    if not hasattr(unittest.TestCase, 'assertCountEqual'):
+        assertCountEqual = unittest.TestCase.assertItemsEqual