Merge ~cjwatson/launchpad:built-using-domination into launchpad:master

[Colin Watson]

Handle Built-Using references in the dominator

Keep source publications with Built-Using references from active binary publications. This may extend to reinstating the source publication (via a copy) if it had already been superseded or deleted.

It's possible for this to cause confusing effects if a manual deletion races with a build that produces binaries with a Built-Using reference to the deleted source. I've guarded against this as best I can, and hope the remaining cases will be rare, but err on the side of honouring the reference.

[Colin Watson (cjwatson)]

I'm reasonably sure that it would be possible to extend this to cover the self-reference case (any active binary publications should keep their parent source publication active too) with minimal trouble, but I've already spent quite a long time on this so haven't attempted to actually do that extension here.

c0c4aa2... by Colin Watson on 2020-04-22

Expand deletion guard to other pockets

It now checks all pockets that could legitimately depend on the one from
which the publication is being deleted.

06ccc3e... by Colin Watson on 2020-04-22

Simplify tests using createFromSourcePackageReleases

88f502f... by Colin Watson on 2020-04-23

Fix Built-Using domination twice in a row

If a source has Built-Using references to it but has already been
superseded by the dominator, then a subsequent run of the dominator will
still consider that source in case reinstatement is needed, and would
fail an assertion when trying to supersede a source that's already
superseded.

The simplest fix for this seems to be to have `planPackageDomination`
not add the publication to `supersede` or `delete` if it's already
inactive.

965bddb... by Colin Watson on 2020-04-23

Tighten up tests slightly

7bfb655... by Colin Watson on 2020-04-23

Fix calculation of live source versions

The dominator previously incorrectly reinstated source publications if
they were the latest one being considered for domination, even if that
was an inactive publication with only inactive Built-Using references.

Unmerged commits

7bfb655... by Colin Watson on 2020-04-23

Fix calculation of live source versions

The dominator previously incorrectly reinstated source publications if
they were the latest one being considered for domination, even if that
was an inactive publication with only inactive Built-Using references.

965bddb... by Colin Watson on 2020-04-23

Tighten up tests slightly

88f502f... by Colin Watson on 2020-04-23

Fix Built-Using domination twice in a row

If a source has Built-Using references to it but has already been
superseded by the dominator, then a subsequent run of the dominator will
still consider that source in case reinstatement is needed, and would
fail an assertion when trying to supersede a source that's already
superseded.

The simplest fix for this seems to be to have `planPackageDomination`
not add the publication to `supersede` or `delete` if it's already
inactive.

f4479f2... by Colin Watson on 2020-03-26

Handle Built-Using references in the dominator

Keep source publications with Built-Using references from active binary
publications. This may extend to reinstating the source publication
(via a copy) if it had already been superseded or deleted.

It's possible for this to cause confusing effects if a manual deletion
races with a build that produces binaries with a Built-Using reference
to the deleted source. I've guarded against this as best I can, and
hope the remaining cases will be rare, but err on the side of honouring
the reference.

LP: #1868558

06ccc3e... by Colin Watson on 2020-04-22

Simplify tests using createFromSourcePackageReleases

c0c4aa2... by Colin Watson on 2020-04-22

Expand deletion guard to other pockets

It now checks all pockets that could legitimately depend on the one from
which the publication is being deleted.

d7fbcfd... by Colin Watson on 2020-03-26

Guard removal of sources referenced by Built-Using

Prevent SourcePackagePublishingHistory.requestDeletion from deleting
source publications that have Built-Using references from active binary
publications in the same archive and suite.

This isn't necessarily complete: in particular, it can miss references
from other pockets, and in any case it might race with a build still in
progress. The intent of this is not to ensure integrity, but to avoid
some easily-detectable mistakes that could cause confusion.

LP: #1868558

diff --git a/lib/lp/archivepublisher/domination.py b/lib/lp/archivepublisher/domination.py
index a02fd78..6721c64 100644
--- a/lib/lp/archivepublisher/domination.py
+++ b/lib/lp/archivepublisher/domination.py
@@ -1,4 +1,4 @@
-# Copyright 2009-2019 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2020 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Archive Domination class.
@@ -68,10 +68,12 @@ from storm.expr import (
     And,
     Count,
     Desc,
+    Or,
     Select,
     )
 from zope.component import getUtility
 
+from lp.app.interfaces.launchpad import ILaunchpadCelebrities
 from lp.registry.model.sourcepackagename import SourcePackageName
 from lp.services.database.bulk import load_related
 from lp.services.database.constants import UTC_NOW
@@ -82,17 +84,24 @@ from lp.services.database.sqlbase import (
     sqlvalues,
     )
 from lp.services.orderingcheck import OrderingCheck
+from lp.soyuz.adapters.archivedependencies import pocket_dependencies
 from lp.soyuz.enums import (
     BinaryPackageFormat,
+    BinarySourceReferenceType,
     PackagePublishingStatus,
     )
+from lp.soyuz.interfaces.binarysourcereference import (
+    IBinarySourceReferenceSet,
+    )
 from lp.soyuz.interfaces.publishing import (
+    active_publishing_status,
     inactive_publishing_status,
     IPublishingSet,
     )
 from lp.soyuz.model.binarypackagebuild import BinaryPackageBuild
 from lp.soyuz.model.binarypackagename import BinaryPackageName
 from lp.soyuz.model.binarypackagerelease import BinaryPackageRelease
+from lp.soyuz.model.binarysourcereference import BinarySourceReference
 from lp.soyuz.model.publishing import (
     BinaryPackagePublishingHistory,
     SourcePackagePublishingHistory,
@@ -207,19 +216,50 @@ class GeneralizedPublication:
         return sorted(publications, cmp=self.compare, reverse=True)
 
 
-def find_live_source_versions(sorted_pubs):
-    """Find versions out of Published publications that should stay live.
+def get_source_versions(source_publications):
+    """List versions for sequence of `SourcePackagePublishingHistory`.
+
+    :param source_publications: An iterable of
+        `SourcePackagePublishingHistory`.
+    :return: A list of the publications' respective versions.
+    """
+    return [pub.sourcepackagerelease.version for pub in source_publications]
 
-    This particular notion of liveness applies to source domination: the
-    latest version stays live, and that's it.
+
+def find_live_source_versions(sorted_pubs, built_using=None):
+    """Find versions of source publications that should stay live.
+
+    This particular notion of liveness applies to source domination:
+    normally, the latest Published version stays live, and that's it.  The
+    exception is if live binary publications have Built-Using fields
+    referring to some source versions, in which case those versions stay
+    live too.
 
     :param sorted_pubs: An iterable of `SourcePackagePublishingHistory`
         sorted by descending package version.
+    :param built_using: An optional collection of `BinarySourceReference`s
+        corresponding to published binary publications with Built-Using
+        references; the SPRs that these refer to should stay live.
     :return: A list of live versions.
     """
+    if built_using is None:
+        built_using = set()
+    built_using_spr_ids = set(
+        bsr.source_package_release_id for bsr in built_using)
+
     # Given the required sort order, the latest version is at the head
     # of the list.
-    return [sorted_pubs[0].sourcepackagerelease.version]
+    sorted_pubs = list(sorted_pubs)
+    live_pubs = []
+    latest = None
+    for pub in sorted_pubs:
+        if latest is None and pub.status == PackagePublishingStatus.PUBLISHED:
+            live_pubs.append(pub)
+            latest = pub
+        elif (pub != latest and
+                pub.sourcepackagereleaseID in built_using_spr_ids):
+            live_pubs.append(pub)
+    return get_source_versions(live_pubs)
 
 
 def get_binary_versions(binary_publications):
@@ -372,11 +412,11 @@ class Dominator:
                               generalization):
         """Plan domination of publications for a single package.
 
-        The latest publication for any version in `live_versions` stays
-        active.  Any older publications (including older publications for
-        live versions with multiple publications) are marked as superseded by
-        the respective oldest live releases that are newer than the superseded
-        ones.
+        The latest active publication for any version in `live_versions`
+        stays active.  Any older active publications (including older
+        publications for live versions with multiple publications) are
+        marked as superseded by the respective oldest live releases that are
+        newer than the superseded ones.
 
         Any versions that are newer than anything in `live_versions` are
         marked as deleted.  This should not be possible in Soyuz-native
@@ -384,11 +424,16 @@ class Dominator:
         previous latest version of a package has disappeared from the Sources
         list we import.
 
+        Inactive publications that are listed in `live_versions` are
+        reinstated.
+
         :param sorted_pubs: A list of publications for the same package,
-            in the same archive, series, and pocket, all with status
-            `PackagePublishingStatus.PUBLISHED`.  They must be sorted from
-            most current to least current, as would be the result of
-            `generalization.sortPublications`.
+            in the same archive, series, and pocket.  These will normally
+            all have status `PackagePublishingStatus.PUBLISHED`, but source
+            publications referenced by Built-Using may reach here with
+            different statuses and be considered for reinstatement.  They
+            must be sorted from most current to least current, as would be
+            the result of `generalization.sortPublications`.
         :param live_versions: Iterable of versions that are still considered
             "live" for this package.  For any of these, the latest publication
             among `publications` will remain Published.  Publications for
@@ -434,28 +479,38 @@ class Dominator:
                 # This publication is for a live version, but has been
                 # superseded by a newer publication of the same version.
                 # Supersede it.
-                supersede.append((pub, current_dominant))
-                self.logger.debug2(
-                    "Superseding older publication for version %s.", version)
+                if pub.status in active_publishing_status:
+                    supersede.append((pub, current_dominant))
+                    self.logger.debug2(
+                        "Superseding older publication for version %s.",
+                        version)
             elif version in live_versions:
-                # This publication stays active; if any publications
-                # that follow right after this are to be superseded,
-                # this is the release that they are superseded by.
-                current_dominant = pub
-                dominant_version = version
-                keep.add(pub)
-                self.logger.debug2("Keeping version %s.", version)
+                if pub.status in active_publishing_status:
+                    # This publication stays active; if any publications
+                    # that follow right after this are to be superseded,
+                    # this is the release that they are superseded by.
+                    current_dominant = pub
+                    dominant_version = version
+                    keep.add(pub)
+                    self.logger.debug2("Keeping version %s.", version)
+                else:
+                    # This publication is currently inactive, but is
+                    # referenced by an active publication.  Reinstate it.
+                    keep.add(pub)
+                    self.logger.debug2("Reinstating version %s.", version)
             elif current_dominant is None:
                 # This publication is no longer live, but there is no
                 # newer version to supersede it either.  Therefore it
                 # must be deleted.
-                delete.append(pub)
-                self.logger.debug2("Deleting version %s.", version)
+                if pub.status in active_publishing_status:
+                    delete.append(pub)
+                    self.logger.debug2("Deleting version %s.", version)
             else:
                 # This publication is superseded.  This is what we're
                 # here to do.
-                supersede.append((pub, current_dominant))
-                self.logger.debug2("Superseding version %s.", version)
+                if pub.status in active_publishing_status:
+                    supersede.append((pub, current_dominant))
+                    self.logger.debug2("Superseding version %s.", version)
 
         return supersede, keep, delete
 
@@ -707,19 +762,22 @@ class Dominator:
 
         execute_plan()
 
-    def _composeActiveSourcePubsCondition(self, distroseries, pocket):
+    def _composeRelevantSourcePubsCondition(self, distroseries, pocket,
+                                            active=True):
         """Compose ORM condition for restricting relevant source pubs."""
         SPPH = SourcePackagePublishingHistory
 
-        return And(
-            SPPH.status == PackagePublishingStatus.PUBLISHED,
+        clauses = [
             SPPH.distroseries == distroseries,
             SPPH.archive == self.archive,
             SPPH.pocket == pocket,
-            )
+            ]
+        if active:
+            clauses.append(SPPH.status == PackagePublishingStatus.PUBLISHED)
+        return And(*clauses)
 
     def findSourcesForDomination(self, distroseries, pocket):
-        """Find binary publications that need dominating.
+        """Find source publications that need dominating.
 
         This is only for traditional domination, where the latest published
         publication is always kept published.  See `find_live_source_versions`
@@ -728,17 +786,32 @@ class Dominator:
         To optimize for that logic, `findSourcesForDomination` will ignore
         publications that have no other publications competing for the same
         binary package.  There'd be nothing to do for those cases.
+
+        This also includes source publications whose source package releases
+        have a Built-Using reference pointing to them, whether active or
+        not.  These may need to be superseded or kept/reinstated depending
+        on whether binary publications referring to them are active.
         """
         SPPH = SourcePackagePublishingHistory
         SPR = SourcePackageRelease
+        BSR = BinarySourceReference
 
-        spph_location_clauses = self._composeActiveSourcePubsCondition(
+        spph_location_clauses = self._composeRelevantSourcePubsCondition(
             distroseries, pocket)
         candidate_source_names = Select(
             SPPH.sourcepackagenameID,
             And(join_spph_spr(), spph_location_clauses),
             group_by=SPPH.sourcepackagenameID,
             having=(Count() > 1))
+        built_using_spph_location_clauses = (
+            self._composeRelevantSourcePubsCondition(
+                distroseries, pocket, active=False))
+        built_using_sprs = Select(
+            SPPH.sourcepackagereleaseID,
+            And(
+                SPPH.sourcepackagereleaseID == BSR.source_package_release_id,
+                BSR.reference_type == BinarySourceReferenceType.BUILT_USING,
+                built_using_spph_location_clauses))
 
         # We'll also access the SourcePackageReleases associated with
         # the publications we find.  Since they're in the join anyway,
@@ -749,8 +822,13 @@ class Dominator:
         query = IStore(SPPH).find(
             (SPPH, SPR),
             join_spph_spr(),
-            SPPH.sourcepackagenameID.is_in(candidate_source_names),
-            spph_location_clauses)
+            Or(
+                And(
+                    SPPH.sourcepackagenameID.is_in(candidate_source_names),
+                    spph_location_clauses),
+                And(
+                    SPPH.sourcepackagereleaseID.is_in(built_using_sprs),
+                    built_using_spph_location_clauses)))
         spphs = DecoratedResultSet(query, itemgetter(0))
         load_related(SourcePackageName, spphs, ['sourcepackagenameID'])
         return spphs
@@ -771,20 +849,57 @@ class Dominator:
         sources = self.findSourcesForDomination(distroseries, pocket)
         sorted_packages = self._sortPackages(sources, generalization)
         supersede = []
+        keep = set()
         delete = []
 
+        # Of the SPRs associated with publications being considered for
+        # domination, find those that have a Built-Using reference pointing
+        # to them from a live binary publication.
+        bsr_set = getUtility(IBinarySourceReferenceSet)
+        reverse_pockets = {
+            source_pocket
+            for source_pocket, expanded_pockets in pocket_dependencies.items()
+            if pocket in expanded_pockets}
+        built_using = bsr_set.findPublished(
+            self.archive, distroseries, reverse_pockets,
+            BinarySourceReferenceType.BUILT_USING,
+            source_package_releases=[
+                pub.sourcepackagerelease for pub in sources])
+
         self.logger.debug("Dominating sources...")
         for name, pubs in sorted_packages.iteritems():
             self.logger.debug("Dominating %s" % name)
             assert len(pubs) > 0, "Dominating zero sources!"
-            live_versions = find_live_source_versions(pubs)
-            cur_supersede, _, cur_delete = self.planPackageDomination(
+            live_versions = find_live_source_versions(pubs, built_using)
+            cur_supersede, cur_keep, cur_delete = self.planPackageDomination(
                 pubs, live_versions, generalization)
             supersede.extend(cur_supersede)
+            keep.update(cur_keep)
             delete.extend(cur_delete)
 
         for pub, dominant in supersede:
             pub.supersede(dominant, logger=self.logger)
+        for pub in keep:
+            if pub.status not in active_publishing_status:
+                # The dominator thinks that we should keep this package, but
+                # it isn't currently published.  This can happen when a
+                # source package has initially been superseded, but then a
+                # binary package that references it in Built-Using is
+                # published, requiring the source package to be reinstated.
+                # To cope with this, we'll copy the source back into place,
+                # thereby creating a new PENDING publication record for it,
+                # which will cause the publisher to put it back on disk.
+                #
+                # In general we'd prefer that the dominator not undo manual
+                # deletions, but Built-Using often expresses a compliance
+                # requirement, so we intentionally don't check that here.
+                # Instead, SPPH.requestDeletion checks for live
+                # BinarySourceReferences, and the uploader rejects uploads
+                # of builds with Built-Using references to source packages
+                # that have been manually deleted.
+                pub.copyTo(
+                    distroseries, pocket, self.archive,
+                    creator=getUtility(ILaunchpadCelebrities).janitor)
         for pub in delete:
             pub.requestDeletion(None)
 
@@ -804,7 +919,7 @@ class Dominator:
             looking_for,
             join_spph_spr(),
             join_spph_spn(),
-            self._composeActiveSourcePubsCondition(distroseries, pocket))
+            self._composeRelevantSourcePubsCondition(distroseries, pocket))
         return result.group_by(SourcePackageName.name)
 
     def findPublishedSPPHs(self, distroseries, pocket, package_name):
@@ -817,7 +932,7 @@ class Dominator:
             join_spph_spr(),
             join_spph_spn(),
             SourcePackageName.name == package_name,
-            self._composeActiveSourcePubsCondition(distroseries, pocket))
+            self._composeRelevantSourcePubsCondition(distroseries, pocket))
         # Sort by descending version (SPR.version has type debversion in
         # the database, so this should be a real proper comparison) so
         # that _sortPackage will have slightly less work to do later.
diff --git a/lib/lp/archivepublisher/tests/test_dominator.py b/lib/lp/archivepublisher/tests/test_dominator.py
index b88da56..7db5336 100755
--- a/lib/lp/archivepublisher/tests/test_dominator.py
+++ b/lib/lp/archivepublisher/tests/test_dominator.py
@@ -1,4 +1,4 @@
-# Copyright 2009-2019 Canonical Ltd.  This software is licensed under the
+# Copyright 2009-2020 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Tests for domination.py."""
@@ -14,6 +14,8 @@ import apt_pkg
 from testtools.matchers import (
     GreaterThan,
     LessThan,
+    MatchesSetwise,
+    MatchesStructure,
     )
 import transaction
 from zope.component import getUtility
@@ -397,6 +399,186 @@ class TestDominator(TestNativePublishingBase):
         for pub in overrides_2:
             self.assertEqual(PackagePublishingStatus.PUBLISHED, pub.status)
 
+    def test_dominateSources_keeps_built_using_refs(self):
+        # If a source publication has a Built-Using reference from an active
+        # binary publication in the same archive and series and in a pocket
+        # that could legitimately refer to it, it is retained.
+        foo_10_src = self.getPubSource(
+            sourcename="foo", version="1.0", architecturehintlist="i386",
+            status=PackagePublishingStatus.PUBLISHED)
+        [foo_10_i386_bin] = self.getPubBinaries(
+            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,
+            architecturespecific=True, version="1.0", pub_source=foo_10_src)
+        foo_11_src = self.getPubSource(
+            sourcename="foo", version="1.1", architecturehintlist="i386",
+            status=PackagePublishingStatus.PUBLISHED)
+        [foo_11_i386_bin] = self.getPubBinaries(
+            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,
+            architecturespecific=True, version="1.1", pub_source=foo_11_src)
+        bar_10_src = self.getPubSource(
+            sourcename="bar", version="1.0", architecturehintlist="i386",
+            status=PackagePublishingStatus.PUBLISHED)
+        [bar_10_i386_bin] = self.getPubBinaries(
+            binaryname="bar-bin", status=PackagePublishingStatus.PUBLISHED,
+            architecturespecific=True, version="1.0", pub_source=bar_10_src,
+            built_using="foo (= 1.0)")
+
+        dominator = Dominator(self.logger, self.ubuntutest.main_archive)
+        dominator.judgeAndDominate(foo_10_src.distroseries, foo_10_src.pocket)
+
+        self.checkPublications(
+            [foo_10_src,
+             foo_11_src, foo_11_i386_bin,
+             bar_10_src, bar_10_i386_bin],
+            PackagePublishingStatus.PUBLISHED)
+        self.checkPublication(
+            foo_10_i386_bin, PackagePublishingStatus.SUPERSEDED)
+
+        # No copies were performed.
+        pending_srcs = foo_10_src.archive.getPublishedSources(
+            status=PackagePublishingStatus.PENDING)
+        pending_bins = foo_10_src.archive.getAllPublishedBinaries(
+            status=PackagePublishingStatus.PENDING)
+        self.assertEqual(0, pending_srcs.count())
+        self.assertEqual(0, pending_bins.count())
+
+        bar_11_src = self.getPubSource(
+            sourcename="bar", version="1.1", architecturehintlist="i386",
+            status=PackagePublishingStatus.PUBLISHED)
+        [bar_11_i386_bin] = self.getPubBinaries(
+            binaryname="bar-bin", status=PackagePublishingStatus.PUBLISHED,
+            architecturespecific=True, version="1.1", pub_source=bar_11_src,
+            built_using="foo (= 1.1)")
+
+        # Dominate twice to make sure the result is stable.
+        for _ in range(2):
+            dominator.judgeAndDominate(
+                foo_10_src.distroseries, foo_10_src.pocket)
+
+            self.checkPublications(
+                [foo_11_src, foo_11_i386_bin,
+                 bar_11_src, bar_11_i386_bin],
+                PackagePublishingStatus.PUBLISHED)
+            self.checkPublications(
+                [foo_10_src, foo_10_i386_bin,
+                 bar_10_src, bar_10_i386_bin],
+                PackagePublishingStatus.SUPERSEDED)
+
+            # No copies were performed.
+            pending_srcs = foo_10_src.archive.getPublishedSources(
+                status=PackagePublishingStatus.PENDING)
+            pending_bins = foo_10_src.archive.getAllPublishedBinaries(
+                status=PackagePublishingStatus.PENDING)
+            self.assertEqual(0, pending_srcs.count())
+            self.assertEqual(0, pending_bins.count())
+
+    def test_dominateSources_reinstates_superseded_built_using_refs(self):
+        # If a superseded source publication has a Built-Using reference
+        # from an active binary publication in the same archive and series
+        # and in a pocket that could legitimately refer to it, it is
+        # reinstated.
+        foo_10_src = self.getPubSource(
+            sourcename="foo", version="1.0", architecturehintlist="i386",
+            status=PackagePublishingStatus.PUBLISHED)
+        [foo_10_i386_bin] = self.getPubBinaries(
+            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,
+            architecturespecific=True, version="1.0", pub_source=foo_10_src)
+        foo_11_src = self.getPubSource(
+            sourcename="foo", version="1.1", architecturehintlist="i386",
+            status=PackagePublishingStatus.PUBLISHED)
+        [foo_11_i386_bin] = self.getPubBinaries(
+            binaryname="foo-bin", status=PackagePublishingStatus.PUBLISHED,
+            architecturespecific=True, version="1.1", pub_source=foo_11_src)
+        bar_10_src = self.getPubSource(
+            sourcename="bar", version="1.0", architecturehintlist="i386",
+            status=PackagePublishingStatus.PUBLISHED,
+            pocket=PackagePublishingPocket.PROPOSED)
+
+        dominator = Dominator(self.logger, self.ubuntutest.main_archive)
+        dominator.judgeAndDominate(foo_10_src.distroseries, foo_10_src.pocket)
+
+        self.checkPublications(
+            [foo_11_src, foo_11_i386_bin,
+             bar_10_src],
+            PackagePublishingStatus.PUBLISHED)
+        self.checkPublications(
+            [foo_10_src, foo_10_i386_bin], PackagePublishingStatus.SUPERSEDED)
+
+        [bar_10_i386_bin] = self.getPubBinaries(
+            binaryname="bar-bin", status=PackagePublishingStatus.PUBLISHED,
+            pocket=PackagePublishingPocket.PROPOSED, architecturespecific=True,
+            version="1.0", pub_source=bar_10_src, built_using="foo (= 1.0)")
+
+        # Dominate twice to make sure the result is stable.
+        for _ in range(2):
+            dominator.judgeAndDominate(
+                foo_10_src.distroseries, foo_10_src.pocket)
+
+            self.checkPublications(
+                [foo_11_src, foo_11_i386_bin,
+                 bar_10_src, bar_10_i386_bin],
+                PackagePublishingStatus.PUBLISHED)
+            self.checkPublications(
+                [foo_10_src, foo_10_i386_bin],
+                PackagePublishingStatus.SUPERSEDED)
+
+            # The foo 1.0 source was reinstated.
+            pending_srcs = foo_10_src.archive.getPublishedSources(
+                status=PackagePublishingStatus.PENDING)
+            pending_bins = foo_10_src.archive.getAllPublishedBinaries(
+                status=PackagePublishingStatus.PENDING)
+            self.assertThat(pending_srcs, MatchesSetwise(
+                MatchesStructure(
+                    sourcepackagerelease=MatchesStructure.byEquality(
+                        name="foo", version="1.0"))))
+            self.assertEqual(0, pending_bins.count())
+
+    def test_dominateSources_skips_inactive_built_using_refs(self):
+        # While inactive source publications are considered for
+        # reinstatement if they are referenced by Built-Using from any
+        # binary publication, they are only actually reinstated if they are
+        # referenced from an *active* binary publication; merely being the
+        # most recent publication of the source package in question is not
+        # enough.
+        foo_10_src = self.getPubSource(
+            sourcename="foo", version="1.0", architecturehintlist="i386",
+            status=PackagePublishingStatus.SUPERSEDED)
+        foo_11_src = self.getPubSource(
+            sourcename="foo", version="1.1", architecturehintlist="i386",
+            status=PackagePublishingStatus.DELETED)
+        bar_10_src = self.getPubSource(
+            sourcename="bar", version="1.0", architecturehintlist="i386",
+            status=PackagePublishingStatus.SUPERSEDED)
+        [bar_10_i386_bin] = self.getPubBinaries(
+            binaryname="bar-bin", status=PackagePublishingStatus.SUPERSEDED,
+            architecturespecific=True, version="1.0", pub_source=bar_10_src,
+            built_using="foo (= 1.0)")
+        bar_11_src = self.getPubSource(
+            sourcename="bar", version="1.1", architecturehintlist="i386",
+            status=PackagePublishingStatus.SUPERSEDED)
+        [bar_11_i386_bin] = self.getPubBinaries(
+            binaryname="bar-bin", status=PackagePublishingStatus.SUPERSEDED,
+            architecturespecific=True, version="1.1", pub_source=bar_11_src,
+            built_using="foo (= 1.1)")
+
+        dominator = Dominator(self.logger, self.ubuntutest.main_archive)
+        dominator.judgeAndDominate(foo_10_src.distroseries, foo_10_src.pocket)
+
+        self.checkPublications(
+            [foo_10_src,
+             bar_10_src, bar_10_i386_bin,
+             bar_11_src, bar_11_i386_bin],
+            PackagePublishingStatus.SUPERSEDED)
+        self.checkPublications([foo_11_src], PackagePublishingStatus.DELETED)
+
+        # No copies were performed.
+        pending_srcs = foo_10_src.archive.getPublishedSources(
+            status=PackagePublishingStatus.PENDING)
+        pending_bins = foo_10_src.archive.getAllPublishedBinaries(
+            status=PackagePublishingStatus.PENDING)
+        self.assertEqual(0, pending_srcs.count())
+        self.assertEqual(0, pending_bins.count())
+
 
 class TestDomination(TestNativePublishingBase):
     """Test overall domination procedure."""
diff --git a/lib/lp/soyuz/interfaces/binarysourcereference.py b/lib/lp/soyuz/interfaces/binarysourcereference.py
index e625cf9..d110256 100644
--- a/lib/lp/soyuz/interfaces/binarysourcereference.py
+++ b/lib/lp/soyuz/interfaces/binarysourcereference.py
@@ -47,6 +47,14 @@ class IBinarySourceReference(Interface):
         vocabulary=BinarySourceReferenceType,
         required=True, readonly=True)
 
+    # Export IDs for use by the dominator.
+    binary_package_release_id = Int(
+        title=_("The referencing binary package release ID."),
+        required=True, readonly=True)
+    source_package_release_id = Int(
+        title=_("The referencing source package release ID."),
+        required=True, readonly=True)
+
 
 class IBinarySourceReferenceSet(Interface):
     """A set of references from binary packages to source packages."""