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

[Colin Watson]

Parse Built-Using fields from uploaded binaries

These are parsed into a form that we'll later be able to use in the dominator, with the goal of keeping source publications that are referenced by Built-Using fields in active binary publications.

The most complicated bit is working out which source package releases a given Built-Using field refers to, since there are edge cases where just the name and version can be ambiguous. We do the best we can by following the archive dependencies of the build and finding sources that it could plausibly have used.

Unresolvable entries in Built-Using, including ones that refer to deleted source publications, will result in binary uploads being rejected.

Database MP: https://code.launchpad.net/~cjwatson/launchpad/+git/launchpad/+merge/381036

[William Grant (wgrant)]

review: Approve (direction)

de9e46b... by Colin Watson on 2020-04-17

Explicitly check "build.current_component is None"

This can happen in tests, especially of gina, and the resulting crash is
a bit confusing, so let's raise a clearer exception in this case.

fde0f10... by Colin Watson on 2020-04-17

Preserve original Built-Using fields for publication

We aren't sure whether apt will get confused if the exact serialisation
(e.g. ordering) of Built-Using in Packages differs from that in the
package's control file, so let's preserve it rather than trying to
reconstruct it.

0692e86... by Colin Watson on 2020-04-17

Don't consider SPPH.status when creating BSRs

We don't normally treat SUPERSEDED differently from DELETED in this sort
of situation, and at that point it isn't really worth checking the
status at all.

a4163e3... by Colin Watson on 2020-04-20

Add more vertical whitespace

7ca1f32... by Colin Watson on 2020-04-21

Limit Built-Using references to the same archive and series

Allowing cross-archive references makes the dominator's job harder, as
well as permitting non-consensual pinning of sources to the Published
state in foreign archives. Forbidding such references may be confusing
in some cases, but seems likely to be less bad than the alternative.

8983670... by Colin Watson on 2020-04-21

Refactor createFromRelationship using Archive.getPublishedSources

Now that we're only considering a single archive, this is equivalent and
much clearer.

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

Add BinarySourceReference.createFromSourcePackageReleases

This makes some tests (especially in branches further up this stack)
more convenient.

[Tom Wardill (twom)]

What is the possible 'unfortunate apt behaviour'?

review: Needs Information

6fd4090... by Colin Watson on 2020-04-23

Clarify "unfortunate apt behaviour"

4f4c880... by Colin Watson on 2020-04-23

Give IBinaryPackageRelease.built_using_references a value_type

[Colin Watson (cjwatson)]

I've clarified this.

[Tom Wardill (twom)]

The model and implementation for this seem to make sense. I'm not entirely fluent in apt behaviours, but this LGTM :).

review: Approve

diff --git a/database/schema/security.cfg b/database/schema/security.cfg
index a0cf410..5ead0b8 100644
--- a/database/schema/security.cfg
+++ b/database/schema/security.cfg
@@ -1213,6 +1213,7 @@ public.binarypackagefile                = SELECT, INSERT, UPDATE
 public.binarypackagename                = SELECT, INSERT, UPDATE
 public.binarypackagepublishinghistory   = SELECT, INSERT, UPDATE, DELETE
 public.binarypackagerelease             = SELECT, INSERT, UPDATE
+public.binarysourcereference            = SELECT, INSERT
 public.branch                           = SELECT, INSERT, UPDATE
 public.bug                              = SELECT, INSERT, UPDATE
 public.bugactivity                      = SELECT, INSERT, UPDATE
@@ -1385,6 +1386,7 @@ public.binarypackagefile                = SELECT, INSERT
 public.binarypackagename                = SELECT, INSERT
 public.binarypackagepublishinghistory   = SELECT
 public.binarypackagerelease             = SELECT, INSERT
+public.binarysourcereference            = SELECT, INSERT
 public.bug                              = SELECT, UPDATE
 public.bugactivity                      = SELECT, INSERT
 public.bugaffectsperson                 = SELECT, INSERT, UPDATE, DELETE
diff --git a/lib/lp/archiveuploader/nascentuploadfile.py b/lib/lp/archiveuploader/nascentuploadfile.py
index aa0ec95..f28e43e 100644
--- a/lib/lp/archiveuploader/nascentuploadfile.py
+++ b/lib/lp/archiveuploader/nascentuploadfile.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).
 
 """Specific models for uploaded files"""
@@ -445,6 +445,12 @@ class BaseBinaryUploadFile(PackageUploadFile):
         "Provides",
         "Pre-Depends",
         "Enhances",
+        # Note that we intentionally don't include Built-Using here;
+        # although we parse it, we want to preserve its original form to
+        # make sure apt doesn't decide that it needs to keep re-upgrading
+        # the package to the same version because the metadata looks
+        # slightly out of sync.  This is most easily done by adding it to
+        # user_defined_fields.
         "Essential",
         "Description",
         "Installed-Size",
@@ -920,6 +926,7 @@ class BaseBinaryUploadFile(PackageUploadFile):
             pre_depends=encoded.get('Pre-Depends', ''),
             enhances=encoded.get('Enhances', ''),
             breaks=encoded.get('Breaks', ''),
+            built_using=encoded.get('Built-Using', ''),
             homepage=encoded.get('Homepage'),
             essential=is_essential,
             installedsize=installedsize,
diff --git a/lib/lp/archiveuploader/tests/test_nascentuploadfile.py b/lib/lp/archiveuploader/tests/test_nascentuploadfile.py
index 54841a9..ff63636 100644
--- a/lib/lp/archiveuploader/tests/test_nascentuploadfile.py
+++ b/lib/lp/archiveuploader/tests/test_nascentuploadfile.py
@@ -1,4 +1,4 @@
-# Copyright 2010-2019 Canonical Ltd.  This software is licensed under the
+# Copyright 2010-2020 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Test NascentUploadFile functionality."""
@@ -26,6 +26,8 @@ from testtools.matchers import (
     MatchesAny,
     MatchesListwise,
     MatchesRegex,
+    MatchesSetwise,
+    MatchesStructure,
     )
 
 from lp.archiveuploader.changesfile import ChangesFile
@@ -43,6 +45,7 @@ from lp.services.compat import lzma
 from lp.services.log.logger import BufferLogger
 from lp.services.osutils import write_file
 from lp.soyuz.enums import (
+    BinarySourceReferenceType,
     PackagePublishingStatus,
     PackageUploadCustomFormat,
     )
@@ -573,6 +576,31 @@ class DebBinaryUploadFileTests(PackageUploadFileTestCase):
                 [u"RandomData", u"Foo\nbar\nbla\n"],
             ], bpr.user_defined_fields)
 
+    def test_built_using(self):
+        # storeInDatabase parses Built-Using into BinarySourceReference
+        # rows, and also adds the unparsed contents to user_defined_fields.
+        uploadfile = self.createDebBinaryUploadFile(
+            "foo_0.42_i386.deb", "main/python", "unknown", "mypkg", "0.42",
+            None)
+        control = self.getBaseControl()
+        control["Built-Using"] = b"bar (= 0.1)"
+        uploadfile.parseControl(control)
+        build = self.factory.makeBinaryPackageBuild()
+        spph = self.factory.makeSourcePackagePublishingHistory(
+            archive=build.archive, distroseries=build.distro_series,
+            pocket=build.pocket, sourcepackagename="bar", version="0.1")
+        bpr = uploadfile.storeInDatabase(build)
+        self.assertThat(
+            bpr.built_using_references,
+            MatchesSetwise(
+                MatchesStructure.byEquality(
+                    binary_package_release=bpr,
+                    source_package_release=spph.sourcepackagerelease,
+                    reference_type=BinarySourceReferenceType.BUILT_USING,
+                    )))
+        self.assertEqual(
+            [[u"Built-Using", u"bar (= 0.1)"]], bpr.user_defined_fields)
+
     def test_homepage(self):
         # storeInDatabase stores homepage field.
         uploadfile = self.createDebBinaryUploadFile(
diff --git a/lib/lp/registry/model/distroseries.py b/lib/lp/registry/model/distroseries.py
index 51dbeea..fefc8cd 100644
--- a/lib/lp/registry/model/distroseries.py
+++ b/lib/lp/registry/model/distroseries.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).
 
 """Database classes for a distribution series."""
@@ -124,6 +124,7 @@ from lp.services.propertycache import (
 from lp.services.worlddata.model.language import Language
 from lp.soyuz.enums import (
     ArchivePurpose,
+    BinarySourceReferenceType,
     IndexCompressionType,
     PackagePublishingStatus,
     PackageUploadStatus,
@@ -1138,6 +1139,9 @@ class DistroSeries(SQLBase, BugTargetBase, HasSpecificationsMixin,
 
     def getBinaryPackagePublishing(self, archtag, pocket, component, archive):
         """See `IDistroSeries`."""
+        # Circular import.
+        from lp.soyuz.model.binarysourcereference import BinarySourceReference
+
         bpphs = Store.of(self).find(
             BinaryPackagePublishingHistory,
             DistroArchSeries.distroseries == self,
@@ -1161,6 +1165,22 @@ class DistroSeries(SQLBase, BugTargetBase, HasSpecificationsMixin,
             bpbs = load_related(BinaryPackageBuild, bprs, ["buildID"])
             sprs = load_related(
                 SourcePackageRelease, bpbs, ["source_package_release_id"])
+
+            built_using_bsrs = load_referencing(
+                BinarySourceReference, bprs, ["binary_package_release_id"],
+                extra_conditions=[
+                    BinarySourceReference.reference_type ==
+                        BinarySourceReferenceType.BUILT_USING,
+                    ])
+            # Make sure this is initialised for all BPRs, as some may not
+            # have any BinarySourceReferences.
+            built_using_bsr_map = {bpr: [] for bpr in bprs}
+            for bsr in built_using_bsrs:
+                built_using_bsr_map[bsr.binary_package_release].append(bsr)
+            for bpr, bsrs in built_using_bsr_map.items():
+                get_property_cache(bpr).built_using_references = sorted(
+                    bsrs, key=attrgetter("id"))
+
             bpfs = load_referencing(
                 BinaryPackageFile, bprs, ["binarypackagereleaseID"])
             file_map = collections.defaultdict(list)
diff --git a/lib/lp/soyuz/configure.zcml b/lib/lp/soyuz/configure.zcml
index 89c9d83..2e97958 100644
--- a/lib/lp/soyuz/configure.zcml
+++ b/lib/lp/soyuz/configure.zcml
@@ -70,6 +70,20 @@
             set_attributes="changelog"/>
     </class>
 
+    <!-- BinarySourceReference -->
+
+    <class
+        class="lp.soyuz.model.binarysourcereference.BinarySourceReference">
+        <allow
+            interface="lp.soyuz.interfaces.binarysourcereference.IBinarySourceReference"/>
+    </class>
+    <securedutility
+        class="lp.soyuz.model.binarysourcereference.BinarySourceReferenceSet"
+        provides="lp.soyuz.interfaces.binarysourcereference.IBinarySourceReferenceSet">
+        <allow
+            interface="lp.soyuz.interfaces.binarysourcereference.IBinarySourceReferenceSet"/>
+    </securedutility>
+
         <!-- SourcePackagePublishingHistory -->
 
         <class
diff --git a/lib/lp/soyuz/doc/distroarchseriesbinarypackage.txt b/lib/lp/soyuz/doc/distroarchseriesbinarypackage.txt
index 03d690a..c759bbf 100644
--- a/lib/lp/soyuz/doc/distroarchseriesbinarypackage.txt
+++ b/lib/lp/soyuz/doc/distroarchseriesbinarypackage.txt
@@ -62,6 +62,7 @@ needs to be removed.
     ...      pre_depends=None,
     ...      enhances=None,
     ...      breaks=None,
+    ...      built_using=None,
     ...      essential=False,
     ...      installedsize=0,
     ...      architecturespecific=False,
@@ -106,6 +107,7 @@ needs to be removed.
     ...      pre_depends=None,
     ...      enhances=None,
     ...      breaks=None,
+    ...      built_using=None,
     ...      essential=False,
     ...      installedsize=0,
     ...      architecturespecific=False,
diff --git a/lib/lp/soyuz/enums.py b/lib/lp/soyuz/enums.py
index b8dafa8..641df6b 100644
--- a/lib/lp/soyuz/enums.py
+++ b/lib/lp/soyuz/enums.py
@@ -1,4 +1,4 @@
-# Copyright 2010-2019 Canonical Ltd.  This software is licensed under the
+# Copyright 2010-2020 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
 """Enumerations used in the lp/soyuz modules."""
@@ -13,6 +13,7 @@ __all__ = [
     'archive_suffixes',
     'BinaryPackageFileType',
     'BinaryPackageFormat',
+    'BinarySourceReferenceType',
     'DistroArchSeriesFilterSense',
     'IndexCompressionType',
     'PackageCopyPolicy',
@@ -613,3 +614,15 @@ class DistroArchSeriesFilterSense(DBEnumeratedType):
 
         Packages in this package set are excluded from the distro arch series.
         """)
+
+
+class BinarySourceReferenceType(DBEnumeratedType):
+    """The type of a reference from a binary package to a source package."""
+
+    BUILT_USING = DBItem(1, """
+        Built-Using
+
+        The referencing binary package incorporates part of the referenced
+        source package, and so the referenced source package needs to remain
+        in the archive for as long as the referencing binary package does.
+        """)
diff --git a/lib/lp/soyuz/interfaces/binarypackagebuild.py b/lib/lp/soyuz/interfaces/binarypackagebuild.py
index 8546a85..d811c6c 100644
--- a/lib/lp/soyuz/interfaces/binarypackagebuild.py
+++ b/lib/lp/soyuz/interfaces/binarypackagebuild.py
@@ -1,4 +1,4 @@
-# Copyright 2009-2017 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).
 
 """BinaryPackageBuild interfaces."""
@@ -179,8 +179,8 @@ class IBinaryPackageBuildView(IPackageBuild):
         component, section, priority, installedsize, architecturespecific,
         shlibdeps=None, depends=None, recommends=None, suggests=None,
         conflicts=None, replaces=None, provides=None, pre_depends=None,
-        enhances=None, breaks=None, essential=False, debug_package=None,
-        user_defined_fields=None, homepage=None):
+        enhances=None, breaks=None, built_using=None, essential=False,
+        debug_package=None, user_defined_fields=None, homepage=None):
         """Create and return a `BinaryPackageRelease`.
 
         The binarypackagerelease will be attached to this specific build.
diff --git a/lib/lp/soyuz/interfaces/binarypackagerelease.py b/lib/lp/soyuz/interfaces/binarypackagerelease.py
index 32fe93c..c69a23d 100644
--- a/lib/lp/soyuz/interfaces/binarypackagerelease.py
+++ b/lib/lp/soyuz/interfaces/binarypackagerelease.py
@@ -1,4 +1,4 @@
-# Copyright 2009-2012 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).
 
 """Binary package release interfaces."""
@@ -61,6 +61,11 @@ class IBinaryPackageRelease(Interface):
     pre_depends = TextLine(required=False)
     enhances = TextLine(required=False)
     breaks = TextLine(required=False)
+    built_using_references = List(
+        title=_("Sequence of Built-Using references."),
+        # Really IBinarySourceReference.
+        value_type=Reference(schema=Interface),
+        required=True)
     essential = Bool(required=False)
     installedsize = Int(required=False)
     architecturespecific = Bool(required=True)
diff --git a/lib/lp/soyuz/interfaces/binarysourcereference.py b/lib/lp/soyuz/interfaces/binarysourcereference.py
new file mode 100644
index 0000000..dc21765
--- /dev/null
+++ b/lib/lp/soyuz/interfaces/binarysourcereference.py
@@ -0,0 +1,86 @@
+# Copyright 2020 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Interface for references from binary packages to source packages."""
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'IBinarySourceReference',
+    'IBinarySourceReferenceSet',
+    'UnparsableBuiltUsing',
+    ]
+
+from lazr.restful.fields import Reference
+from zope.interface import Interface
+from zope.schema import (
+    Choice,
+    Int,
+    )
+
+from lp import _
+from lp.soyuz.enums import BinarySourceReferenceType
+from lp.soyuz.interfaces.binarypackagerelease import IBinaryPackageRelease
+from lp.soyuz.interfaces.sourcepackagerelease import ISourcePackageRelease
+
+
+class UnparsableBuiltUsing(Exception):
+    """A Built-Using field could not be parsed."""
+
+
+class IBinarySourceReference(Interface):
+    """A reference from a binary package to a source package."""
+
+    id = Int(title=_("ID"))
+
+    binary_package_release = Reference(
+        IBinaryPackageRelease,
+        title=_("The referencing binary package release."),
+        required=True, readonly=True)
+    source_package_release = Reference(
+        ISourcePackageRelease,
+        title=_("The referenced source package release."),
+        required=True, readonly=True)
+    reference_type = Choice(
+        title=_("The type of the reference."),
+        vocabulary=BinarySourceReferenceType,
+        required=True, readonly=True)
+
+
+class IBinarySourceReferenceSet(Interface):
+    """A set of references from binary packages to source packages."""
+
+    def createFromRelationship(bpr, relationship, reference_type):
+        """Create references from a text relationship field.
+
+        :param bpr: The `IBinaryPackageRelease` from which new references
+            should be created.
+        :param relationship: A text relationship field containing one or
+            more source package relations in the usual Debian encoding (e.g.
+            "source1 (= 1.0), source2 (= 2.0)").
+        :param reference_type: The `BinarySourceReferenceType` of references
+            to create.
+        :return: A list of new `IBinarySourceReference`s.
+        """
+
+    def createFromSourcePackageReleases(bpr, sprs, reference_type):
+        """Create references from a sequence of source package releases.
+
+        This is a convenience method for use in tests.
+
+        :param bpr: The `IBinaryPackageRelease` from which new references
+            should be created.
+        :param sprs: A sequence of `ISourcePackageRelease`s.
+        :param reference_type: The `BinarySourceReferenceType` of references
+            to create.
+        :return: A list of new `IBinarySourceReference`s.
+        """
+
+    def findByBinaryPackageRelease(bpr, reference_type):
+        """Find references from a given binary package release.
+
+        :param bpr: An `IBinaryPackageRelease` to search for.
+        :param reference_type: A `BinarySourceReferenceType` to search for.
+        :return: A `ResultSet` of matching `IBinarySourceReference`s.
+        """
diff --git a/lib/lp/soyuz/model/binarypackagebuild.py b/lib/lp/soyuz/model/binarypackagebuild.py
index ae4f1de..470a8f2 100644
--- a/lib/lp/soyuz/model/binarypackagebuild.py
+++ b/lib/lp/soyuz/model/binarypackagebuild.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).
 
 __metaclass__ = type
@@ -91,6 +91,7 @@ from lp.services.macaroons.model import MacaroonIssuerBase
 from lp.soyuz.adapters.buildarch import determine_architectures_to_build
 from lp.soyuz.enums import (
     ArchivePurpose,
+    BinarySourceReferenceType,
     PackagePublishingStatus,
     )
 from lp.soyuz.interfaces.archive import (
@@ -104,6 +105,9 @@ from lp.soyuz.interfaces.binarypackagebuild import (
     IBinaryPackageBuildSet,
     UnparsableDependencies,
     )
+from lp.soyuz.interfaces.binarysourcereference import (
+    IBinarySourceReferenceSet,
+    )
 from lp.soyuz.interfaces.distroarchseries import IDistroArchSeries
 from lp.soyuz.interfaces.packageset import IPackagesetSet
 from lp.soyuz.mail.binarypackagebuild import BinaryPackageBuildMailer
@@ -662,10 +666,11 @@ class BinaryPackageBuild(PackageBuildMixin, SQLBase):
         binpackageformat, component, section, priority, installedsize,
         architecturespecific, shlibdeps=None, depends=None, recommends=None,
         suggests=None, conflicts=None, replaces=None, provides=None,
-        pre_depends=None, enhances=None, breaks=None, essential=False,
-        debug_package=None, user_defined_fields=None, homepage=None):
+        pre_depends=None, enhances=None, breaks=None, built_using=None,
+        essential=False, debug_package=None, user_defined_fields=None,
+        homepage=None):
         """See IBuild."""
-        return BinaryPackageRelease(
+        bpr = BinaryPackageRelease(
             build=self, binarypackagename=binarypackagename, version=version,
             summary=summary, description=description,
             binpackageformat=binpackageformat,
@@ -677,6 +682,10 @@ class BinaryPackageBuild(PackageBuildMixin, SQLBase):
             architecturespecific=architecturespecific,
             debug_package=debug_package,
             user_defined_fields=user_defined_fields, homepage=homepage)
+        if built_using:
+            getUtility(IBinarySourceReferenceSet).createFromRelationship(
+                bpr, built_using, BinarySourceReferenceType.BUILT_USING)
+        return bpr
 
     def estimateDuration(self):
         """See `IPackageBuild`."""
diff --git a/lib/lp/soyuz/model/binarypackagerelease.py b/lib/lp/soyuz/model/binarypackagerelease.py
index ad4f514..3458b70 100644
--- a/lib/lp/soyuz/model/binarypackagerelease.py
+++ b/lib/lp/soyuz/model/binarypackagerelease.py
@@ -1,4 +1,4 @@
-# Copyright 2009-2012 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).
 
 __metaclass__ = type
@@ -7,6 +7,7 @@ __all__ = [
     'BinaryPackageReleaseDownloadCount',
     ]
 
+from operator import attrgetter
 
 import simplejson
 from sqlobject import (
@@ -22,6 +23,7 @@ from storm.locals import (
     Store,
     Storm,
     )
+from zope.component import getUtility
 from zope.interface import implementer
 
 from lp.services.database.constants import UTC_NOW
@@ -35,12 +37,16 @@ from lp.services.propertycache import (
 from lp.soyuz.enums import (
     BinaryPackageFileType,
     BinaryPackageFormat,
+    BinarySourceReferenceType,
     PackagePublishingPriority,
     )
 from lp.soyuz.interfaces.binarypackagerelease import (
     IBinaryPackageRelease,
     IBinaryPackageReleaseDownloadCount,
     )
+from lp.soyuz.interfaces.binarysourcereference import (
+    IBinarySourceReferenceSet,
+    )
 from lp.soyuz.model.files import BinaryPackageFile
 
 
@@ -89,6 +95,14 @@ class BinaryPackageRelease(SQLBase):
             del kwargs['user_defined_fields']
         super(BinaryPackageRelease, self).__init__(*args, **kwargs)
 
+    @cachedproperty
+    def built_using_references(self):
+        reference_set = getUtility(IBinarySourceReferenceSet)
+        references = reference_set.findByBinaryPackageRelease(
+            self, BinarySourceReferenceType.BUILT_USING)
+        # Preserving insertion order is good enough.
+        return sorted(references, key=attrgetter('id'))
+
     @property
     def user_defined_fields(self):
         """See `IBinaryPackageRelease`."""
diff --git a/lib/lp/soyuz/model/binarysourcereference.py b/lib/lp/soyuz/model/binarysourcereference.py
new file mode 100644
index 0000000..adcfb6f
--- /dev/null
+++ b/lib/lp/soyuz/model/binarysourcereference.py
@@ -0,0 +1,149 @@
+# Copyright 2020 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""References from binary packages to source packages."""
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+__metaclass__ = type
+__all__ = [
+    'BinarySourceReference',
+    'BinarySourceReferenceSet',
+    ]
+
+import warnings
+
+from debian.deb822 import PkgRelation
+from storm.locals import (
+    Int,
+    Reference,
+    )
+from zope.interface import implementer
+
+from lp.services.database.bulk import create
+from lp.services.database.enumcol import DBEnum
+from lp.services.database.interfaces import IStore
+from lp.services.database.stormbase import StormBase
+from lp.soyuz.adapters.archivedependencies import pocket_dependencies
+from lp.soyuz.enums import BinarySourceReferenceType
+from lp.soyuz.interfaces.binarysourcereference import (
+    IBinarySourceReference,
+    IBinarySourceReferenceSet,
+    UnparsableBuiltUsing,
+    )
+
+
+@implementer(IBinarySourceReference)
+class BinarySourceReference(StormBase):
+    """See `IBinarySourceReference`."""
+
+    __storm_table__ = "BinarySourceReference"
+
+    id = Int(primary=True)
+
+    binary_package_release_id = Int(
+        name="binary_package_release", allow_none=False)
+    binary_package_release = Reference(
+        binary_package_release_id, "BinaryPackageRelease.id")
+
+    source_package_release_id = Int(
+        name="source_package_release", allow_none=False)
+    source_package_release = Reference(
+        source_package_release_id, "SourcePackageRelease.id")
+
+    reference_type = DBEnum(enum=BinarySourceReferenceType, allow_none=False)
+
+    def __init__(self, binary_package_release, source_package_release,
+                 reference_type):
+        """Construct a `BinarySourceReference`."""
+        super(BinarySourceReference, self).__init__()
+        self.binary_package_release = binary_package_release
+        self.source_package_release = source_package_release
+        self.reference_type = reference_type
+
+
+@implementer(IBinarySourceReferenceSet)
+class BinarySourceReferenceSet:
+    """See `IBinarySourceReferenceSet`."""
+
+    @classmethod
+    def createFromRelationship(cls, bpr, relationship, reference_type):
+        """See `IBinarySourceReferenceSet`."""
+        if not relationship:
+            return []
+
+        try:
+            with warnings.catch_warnings():
+                warnings.simplefilter("error")
+                parsed_rel = PkgRelation.parse_relations(relationship)
+        except Warning as error:
+            raise UnparsableBuiltUsing(
+                "Invalid Built-Using field; cannot be parsed by deb822: %s"
+                % (error,))
+
+        build = bpr.build
+        values = []
+        for or_rel in parsed_rel:
+            if len(or_rel) != 1:
+                raise UnparsableBuiltUsing(
+                    "Alternatives are not allowed in Built-Using field: %s"
+                    % (PkgRelation.str([or_rel]),))
+            rel = or_rel[0]
+            if rel["version"] is None or rel["version"][0] != "=":
+                raise UnparsableBuiltUsing(
+                    "Built-Using must contain strict dependencies: %s"
+                    % (PkgRelation.str([or_rel]),))
+
+            # "source-package-name (= version)" might refer to any of
+            # several SPRs, for example if the same source package was
+            # uploaded to a PPA and then uploaded separately (not copied -
+            # copies reuse the same SPR) to the distribution's primary
+            # archive.  We need to disambiguate this and find an actual SPR
+            # so that we can efficiently look up references for a given
+            # source publication.
+            #
+            # However, allowing cross-archive references would make the
+            # dominator's job much harder and have other undesirable
+            # properties, such as being able to pin a source in Published in
+            # a foreign archive just by adding it as a dependency and
+            # declaring a Built-Using relationship on it.
+            #
+            # Therefore, as a safe approximation, try this build's pocket
+            # dependencies within its archive and series.  Within this
+            # constraint, a name and version should uniquely identify an
+            # SPR, although we pick the latest by ID just in case that
+            # somehow ends up not being true.
+            closest_spph = build.archive.getPublishedSources(
+                name=rel["name"], version=rel["version"][1],
+                distroseries=build.distro_series,
+                pocket=pocket_dependencies[build.pocket],
+                exact_match=True).first()
+            if closest_spph is None:
+                raise UnparsableBuiltUsing(
+                    "Built-Using refers to source package %s (= %s), which is "
+                    "not known in %s in %s" %
+                    (rel["name"], rel["version"][1],
+                     build.distro_series.name, build.archive.reference))
+            values.append(
+                (bpr.id, closest_spph.sourcepackagereleaseID, reference_type))
+
+        return create(
+            (BinarySourceReference.binary_package_release_id,
+             BinarySourceReference.source_package_release_id,
+             BinarySourceReference.reference_type),
+            values, get_objects=True)
+
+    @classmethod
+    def createFromSourcePackageReleases(cls, bpr, sprs, reference_type):
+        """See `IBinarySourceReferenceSet`."""
+        relationship = ", ".join(
+            ["%s (= %s)" % (spr.name, spr.version) for spr in sprs])
+        return cls.createFromRelationship(bpr, relationship, reference_type)
+
+    @classmethod
+    def findByBinaryPackageRelease(cls, bpr, reference_type):
+        """See `IBinarySourceReferenceSet`."""
+        return IStore(BinarySourceReference).find(
+            BinarySourceReference,
+            BinarySourceReference.binary_package_release == bpr,
+            BinarySourceReference.reference_type == reference_type)
diff --git a/lib/lp/soyuz/scripts/gina/handlers.py b/lib/lp/soyuz/scripts/gina/handlers.py
index 66d2aeb..54539a4 100644
--- a/lib/lp/soyuz/scripts/gina/handlers.py
+++ b/lib/lp/soyuz/scripts/gina/handlers.py
@@ -1,4 +1,4 @@
-# Copyright 2009-2016 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).
 
 """Gina db handlers.
@@ -52,10 +52,15 @@ from lp.services.librarian.interfaces import ILibraryFileAliasSet
 from lp.services.scripts import log
 from lp.soyuz.enums import (
     BinaryPackageFormat,
+    BinarySourceReferenceType,
     PackagePublishingStatus,
     )
 from lp.soyuz.interfaces.binarypackagebuild import IBinaryPackageBuildSet
 from lp.soyuz.interfaces.binarypackagename import IBinaryPackageNameSet
+from lp.soyuz.interfaces.binarysourcereference import (
+    IBinarySourceReferenceSet,
+    UnparsableBuiltUsing,
+    )
 from lp.soyuz.interfaces.publishing import (
     active_publishing_status,
     IPublishingSet,
@@ -820,6 +825,16 @@ class BinaryPackageHandler:
             installedsize=bin.installed_size,
             architecturespecific=architecturespecific,
             **kwargs)
+        try:
+            getUtility(IBinarySourceReferenceSet).createFromRelationship(
+                binpkg, bin.built_using, BinarySourceReferenceType.BUILT_USING)
+        except UnparsableBuiltUsing:
+            # XXX cjwatson 2020-02-03: It might be nice if we created
+            # BinarySourceReference rows at least for those relations that
+            # can be parsed and resolved to SourcePackageReleases.  It's not
+            # worth spending much time on given that we don't use binary
+            # imports much, though.
+            pass
         log.info('Binary Package Release %s (%s) created' %
                  (bin_name.name, bin.version))
 
diff --git a/lib/lp/soyuz/scripts/gina/packages.py b/lib/lp/soyuz/scripts/gina/packages.py
index 4126b80..6e2f090 100644
--- a/lib/lp/soyuz/scripts/gina/packages.py
+++ b/lib/lp/soyuz/scripts/gina/packages.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).
 
 """Package information classes.
@@ -466,6 +466,7 @@ class BinaryPackageData(AbstractPackageData):
     pre_depends = ""
     enhances = ""
     breaks = ""
+    built_using = ""
     essential = False
 
     # Overwritten in do_package, optionally
@@ -493,6 +494,14 @@ class BinaryPackageData(AbstractPackageData):
                 except ValueError:
                     raise MissingRequiredArguments("Installed-Size is "
                         "not a valid integer: %r" % v)
+            elif k == "Built-Using":
+                self.built_using = v
+                # Preserve the original form of Built-Using to avoid
+                # possible unfortunate apt behaviour.  This is most easily
+                # done by adding it to _user_defined as well.
+                if self._user_defined is None:
+                    self._user_defined = []
+                self._user_defined.append([k, v])
             else:
                 self.set_field(k, v)
 
diff --git a/lib/lp/soyuz/scripts/tests/test_gina.py b/lib/lp/soyuz/scripts/tests/test_gina.py
index 2653b4f..9574c38 100644
--- a/lib/lp/soyuz/scripts/tests/test_gina.py
+++ b/lib/lp/soyuz/scripts/tests/test_gina.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).
 
 from doctest import DocTestSuite
@@ -12,6 +12,10 @@ from unittest import TestLoader
 
 import apt_pkg
 from fixtures import EnvironmentVariableFixture
+from testtools.matchers import (
+    MatchesSetwise,
+    MatchesStructure,
+    )
 import transaction
 
 from lp.archiveuploader.tagfiles import parse_tagfile
@@ -22,7 +26,10 @@ from lp.services.features.testing import FeatureFixture
 from lp.services.log.logger import DevNullLogger
 from lp.services.osutils import write_file
 from lp.services.tarfile_helpers import LaunchpadWriteTarFile
-from lp.soyuz.enums import PackagePublishingStatus
+from lp.soyuz.enums import (
+    BinarySourceReferenceType,
+    PackagePublishingStatus,
+    )
 from lp.soyuz.scripts.gina import ExecutionError
 from lp.soyuz.scripts.gina.archive import (
     ArchiveComponentItems,
@@ -483,9 +490,62 @@ class TestBinaryPackageHandler(TestCaseWithFactory):
             "Summary": "",
             "Priority": "extra",
             "Python-Version": "2.7",
+            "Built-Using": "nonexistent (= 0.1)",
+            }
+        bp_data = BinaryPackageData(**deb_contents)
+        self.assertContentEqual(
+            [["Python-Version", "2.7"],
+             ["Built-Using", "nonexistent (= 0.1)"]],
+            bp_data._user_defined)
+        bp_data.archive_root = archive_root
+        # We don't need a real .deb here.
+        write_file(
+            os.path.join(archive_root, "pool/main/f/foo/foo_1.0-1_amd64.deb"),
+            b"x")
+        bpr = bphandler.createBinaryPackage(bp_data, spr, das, "amd64")
+        self.assertIsNotNone(bpr)
+        self.assertEqual([], bpr.built_using_references)
+        self.assertContentEqual(
+            [["Python-Version", "2.7"],
+             ["Built-Using", "nonexistent (= 0.1)"]],
+            bpr.user_defined_fields)
+
+    def test_resolvable_built_using(self):
+        das = self.factory.makeDistroArchSeries()
+        archive_root = self.useTempDir()
+        sphandler = SourcePackageHandler(
+            das.distroseries.distribution.name, archive_root,
+            PackagePublishingPocket.RELEASE, None)
+        bphandler = BinaryPackageHandler(
+            sphandler, archive_root, PackagePublishingPocket.RELEASE)
+        spr = self.factory.makeSourcePackagePublishingHistory(
+            distroseries=das.distroseries,
+            component="main").sourcepackagerelease
+        built_using_spph = self.factory.makeSourcePackagePublishingHistory(
+            archive=das.main_archive, distroseries=das.distroseries,
+            pocket=PackagePublishingPocket.RELEASE)
+        built_using_spr = built_using_spph.sourcepackagerelease
+        built_using_relationship = "%s (= %s)" % (
+            built_using_spr.name, built_using_spr.version)
+        deb_contents = {
+            "Package": "foo",
+            "Installed-Size": "0",
+            "Maintainer": "Foo Bar <[e-mail]>",
+            "Section": "misc",
+            "Architecture": "amd64",
+            "Version": "1.0-1",
+            "Filename": "pool/main/f/foo/foo_1.0-1_amd64.deb",
+            "Component": "main",
+            "Size": "0",
+            "MD5sum": "0" * 32,
+            "Description": "",
+            "Summary": "",
+            "Priority": "extra",
+            "Built-Using": built_using_relationship,
             }
         bp_data = BinaryPackageData(**deb_contents)
-        self.assertEqual([["Python-Version", "2.7"]], bp_data._user_defined)
+        self.assertContentEqual(
+            [["Built-Using", built_using_relationship]], bp_data._user_defined)
         bp_data.archive_root = archive_root
         # We don't need a real .deb here.
         write_file(
@@ -493,7 +553,16 @@ class TestBinaryPackageHandler(TestCaseWithFactory):
             b"x")
         bpr = bphandler.createBinaryPackage(bp_data, spr, das, "amd64")
         self.assertIsNotNone(bpr)
-        self.assertEqual([["Python-Version", "2.7"]], bpr.user_defined_fields)
+        self.assertThat(
+            bpr.built_using_references,
+            MatchesSetwise(
+                MatchesStructure.byEquality(
+                    binary_package_release=bpr,
+                    source_package_release=built_using_spr,
+                    reference_type=BinarySourceReferenceType.BUILT_USING)))
+        self.assertContentEqual(
+            [["Built-Using", built_using_relationship]],
+            bpr.user_defined_fields)
 
 
 class TestBinaryPackagePublisher(TestCaseWithFactory):
diff --git a/lib/lp/soyuz/tests/test_binarysourcereference.py b/lib/lp/soyuz/tests/test_binarysourcereference.py
new file mode 100644
index 0000000..f682de8
--- /dev/null
+++ b/lib/lp/soyuz/tests/test_binarysourcereference.py
@@ -0,0 +1,208 @@
+# Copyright 2020 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Test references from binary packages to source packages."""
+
+from __future__ import absolute_import, print_function, unicode_literals
+
+__metaclass__ = type
+
+import re
+
+from testtools.matchers import (
+    MatchesSetwise,
+    MatchesStructure,
+    )
+from testtools.testcase import ExpectedException
+from zope.component import getUtility
+
+from lp.registry.interfaces.pocket import PackagePublishingPocket
+from lp.soyuz.enums import (
+    ArchivePurpose,
+    BinarySourceReferenceType,
+    )
+from lp.soyuz.interfaces.binarysourcereference import (
+    IBinarySourceReferenceSet,
+    UnparsableBuiltUsing,
+    )
+from lp.testing import TestCaseWithFactory
+from lp.testing.layers import DatabaseFunctionalLayer
+
+
+class TestBinarySourceReference(TestCaseWithFactory):
+
+    layer = DatabaseFunctionalLayer
+
+    def setUp(self):
+        super(TestBinarySourceReference, self).setUp()
+        self.reference_set = getUtility(IBinarySourceReferenceSet)
+
+    def test_createFromRelationship_empty(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        self.assertEqual(
+            [],
+            self.reference_set.createFromRelationship(
+                bpr, "", BinarySourceReferenceType.BUILT_USING))
+
+    def test_createFromRelationship_nonsense(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        expected_message = (
+            r"Invalid Built-Using field; cannot be parsed by deb822: .*")
+        with ExpectedException(UnparsableBuiltUsing, expected_message):
+            self.reference_set.createFromRelationship(
+                bpr, "nonsense (", BinarySourceReferenceType.BUILT_USING)
+
+    def test_createFromRelationship_alternatives(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        expected_message = (
+            r"Alternatives are not allowed in Built-Using field: "
+            r"foo \(= 1\) \| bar \(= 2\)")
+        with ExpectedException(UnparsableBuiltUsing, expected_message):
+            self.reference_set.createFromRelationship(
+                bpr, "foo (= 1) | bar (= 2)",
+                BinarySourceReferenceType.BUILT_USING)
+
+    def test_createFromRelationship_no_version(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        expected_message = r"Built-Using must contain strict dependencies: foo"
+        with ExpectedException(UnparsableBuiltUsing, expected_message):
+            self.reference_set.createFromRelationship(
+                bpr, "foo", BinarySourceReferenceType.BUILT_USING)
+
+    def test_createFromRelationship_inequality(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        expected_message = (
+            r"Built-Using must contain strict dependencies: foo \(>= 1\)")
+        with ExpectedException(UnparsableBuiltUsing, expected_message):
+            self.reference_set.createFromRelationship(
+                bpr, "foo (>= 1)", BinarySourceReferenceType.BUILT_USING)
+
+    def test_createFromRelationship_unknown_source_package_name(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        relationship = "nonexistent (= 1)"
+        expected_message = (
+            r"Built-Using refers to source package %s, which is not known in "
+            r"%s in %s" % (
+                re.escape(relationship), bpr.build.distro_series.name,
+                bpr.build.archive.reference))
+        with ExpectedException(UnparsableBuiltUsing, expected_message):
+            self.reference_set.createFromRelationship(
+                bpr, relationship, BinarySourceReferenceType.BUILT_USING)
+
+    def test_createFromRelationship_unknown_source_package_version(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        spph = self.factory.makeSourcePackagePublishingHistory(
+            archive=bpr.build.archive,
+            distroseries=bpr.build.distro_series,
+            component=bpr.build.current_component)
+        spr = spph.sourcepackagerelease
+        relationship = "%s (= %s.1)" % (spr.name, spr.version)
+        expected_message = (
+            r"Built-Using refers to source package %s, which is not known in "
+            r"%s in %s" % (
+                re.escape(relationship), bpr.build.distro_series.name,
+                bpr.build.archive.reference))
+        with ExpectedException(UnparsableBuiltUsing, expected_message):
+            self.reference_set.createFromRelationship(
+                bpr, relationship, BinarySourceReferenceType.BUILT_USING)
+
+    def test_createFromRelationship_simple(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        spphs = [
+            self.factory.makeSourcePackagePublishingHistory(
+                archive=bpr.build.archive,
+                distroseries=bpr.build.distro_series, pocket=bpr.build.pocket)
+            for _ in range(3)]
+        sprs = [spph.sourcepackagerelease for spph in spphs]
+        # Create a few more SPPHs with slight mismatches to ensure that
+        # createFromRelationship matches correctly.
+        self.factory.makeSourcePackagePublishingHistory(
+            archive=bpr.build.archive, pocket=bpr.build.pocket,
+            sourcepackagename=sprs[0].name, version=sprs[0].version)
+        self.factory.makeSourcePackagePublishingHistory(
+            archive=bpr.build.archive, distroseries=bpr.build.distro_series,
+            pocket=PackagePublishingPocket.BACKPORTS,
+            sourcepackagename=sprs[0].name, version=sprs[0].version)
+        self.factory.makeSourcePackagePublishingHistory(
+            archive=bpr.build.archive, distroseries=bpr.build.distro_series,
+            pocket=bpr.build.pocket, sourcepackagename=sprs[0].name)
+        self.factory.makeSourcePackagePublishingHistory(
+            archive=bpr.build.archive, distroseries=bpr.build.distro_series,
+            pocket=bpr.build.pocket, version=sprs[0].version)
+        self.factory.makeSourcePackagePublishingHistory()
+        relationship = (
+            "%s (= %s), %s (= %s)" %
+            (sprs[0].name, sprs[0].version, sprs[1].name, sprs[1].version))
+        bsrs = self.reference_set.createFromRelationship(
+            bpr, relationship, BinarySourceReferenceType.BUILT_USING)
+        self.assertThat(bsrs, MatchesSetwise(*(
+            MatchesStructure.byEquality(
+                binary_package_release=bpr,
+                source_package_release=spr,
+                reference_type=BinarySourceReferenceType.BUILT_USING)
+            for spr in sprs[:2])))
+
+    def test_createFromRelationship_foreign_archive(self):
+        # createFromRelationship only considers SPRs found in the same
+        # archive as the build.
+        archive = self.factory.makeArchive(purpose=ArchivePurpose.PPA)
+        build = self.factory.makeBinaryPackageBuild(archive=archive)
+        bpr = self.factory.makeBinaryPackageRelease(build=build)
+        spph = self.factory.makeSourcePackagePublishingHistory(
+            archive=build.distro_series.main_archive,
+            distroseries=build.distro_series, pocket=build.pocket)
+        spr = spph.sourcepackagerelease
+        relationship = "%s (= %s)" % (spr.name, spr.version)
+        expected_message = (
+            r"Built-Using refers to source package %s, which is not known in "
+            r"%s in %s" % (
+                re.escape(relationship), build.distro_series.name,
+                build.archive.reference))
+        with ExpectedException(UnparsableBuiltUsing, expected_message):
+            self.reference_set.createFromRelationship(
+                bpr, relationship, BinarySourceReferenceType.BUILT_USING)
+
+    def test_findByBinaryPackageRelease_empty(self):
+        bpr = self.factory.makeBinaryPackageRelease()
+        self.assertContentEqual(
+            [],
+            self.reference_set.findByBinaryPackageRelease(
+                bpr, BinarySourceReferenceType.BUILT_USING))
+
+    def test_findByBinaryPackageRelease(self):
+        bprs = [self.factory.makeBinaryPackageRelease() for _ in range(2)]
+        all_sprs = []
+        for bpr in bprs:
+            spphs = [
+                self.factory.makeSourcePackagePublishingHistory(
+                    archive=bpr.build.archive,
+                    distroseries=bpr.build.distro_series,
+                    pocket=bpr.build.pocket)
+                for _ in range(2)]
+            sprs = [spph.sourcepackagerelease for spph in spphs]
+            all_sprs.extend(sprs)
+            self.reference_set.createFromSourcePackageReleases(
+                bpr, sprs, BinarySourceReferenceType.BUILT_USING)
+        other_bpr = self.factory.makeBinaryPackageRelease()
+        self.assertThat(
+            self.reference_set.findByBinaryPackageRelease(
+                bprs[0], BinarySourceReferenceType.BUILT_USING),
+            MatchesSetwise(*(
+                MatchesStructure.byEquality(
+                    binary_package_release=bprs[0],
+                    source_package_release=spr,
+                    reference_type=BinarySourceReferenceType.BUILT_USING)
+                for spr in all_sprs[:2])))
+        self.assertThat(
+            self.reference_set.findByBinaryPackageRelease(
+                bprs[1], BinarySourceReferenceType.BUILT_USING),
+            MatchesSetwise(*(
+                MatchesStructure.byEquality(
+                    binary_package_release=bprs[1],
+                    source_package_release=spr,
+                    reference_type=BinarySourceReferenceType.BUILT_USING)
+                for spr in all_sprs[2:])))
+        self.assertContentEqual(
+            [],
+            self.reference_set.findByBinaryPackageRelease(
+                other_bpr, BinarySourceReferenceType.BUILT_USING))
diff --git a/lib/lp/soyuz/tests/test_publishing.py b/lib/lp/soyuz/tests/test_publishing.py
index e65003d..cd7d1ea 100644
--- a/lib/lp/soyuz/tests/test_publishing.py
+++ b/lib/lp/soyuz/tests/test_publishing.py
@@ -306,7 +306,8 @@ class SoyuzTestPublisher:
                        shlibdep=None, depends=None, recommends=None,
                        suggests=None, conflicts=None, replaces=None,
                        provides=None, pre_depends=None, enhances=None,
-                       breaks=None, filecontent=b'bbbiiinnnaaarrryyy',
+                       breaks=None, built_using=None,
+                       filecontent=b'bbbiiinnnaaarrryyy',
                        changes_file_content=b"Fake: fake changes file",
                        status=PackagePublishingStatus.PENDING,
                        pocket=PackagePublishingPocket.RELEASE,
@@ -353,7 +354,8 @@ class SoyuzTestPublisher:
                     build, binaryname + '-dbgsym', filecontent, summary,
                     description, shlibdep, depends, recommends, suggests,
                     conflicts, replaces, provides, pre_depends, enhances,
-                    breaks, BinaryPackageFormat.DDEB, version=version)
+                    breaks, built_using, BinaryPackageFormat.DDEB,
+                    version=version)
                 pub_binaries += self.publishBinaryInArchive(
                     binarypackagerelease_ddeb, archive, status,
                     pocket, scheduleddeletiondate, dateremoved,
@@ -364,7 +366,7 @@ class SoyuzTestPublisher:
             binarypackagerelease = self.uploadBinaryForBuild(
                 build, binaryname, filecontent, summary, description,
                 shlibdep, depends, recommends, suggests, conflicts, replaces,
-                provides, pre_depends, enhances, breaks, format,
+                provides, pre_depends, enhances, breaks, built_using, format,
                 binarypackagerelease_ddeb, version=version,
                 user_defined_fields=user_defined_fields)
             pub_binaries += self.publishBinaryInArchive(
@@ -387,8 +389,9 @@ class SoyuzTestPublisher:
         summary="summary", description="description", shlibdep=None,
         depends=None, recommends=None, suggests=None, conflicts=None,
         replaces=None, provides=None, pre_depends=None, enhances=None,
-        breaks=None, format=BinaryPackageFormat.DEB, debug_package=None,
-        user_defined_fields=None, homepage=None, version=None):
+        breaks=None, built_using=None, format=BinaryPackageFormat.DEB,
+        debug_package=None, user_defined_fields=None, homepage=None,
+        version=None):
         """Return the corresponding `BinaryPackageRelease`."""
         sourcepackagerelease = build.source_package_release
         distroarchseries = build.distro_arch_series
@@ -418,6 +421,7 @@ class SoyuzTestPublisher:
             pre_depends=pre_depends,
             enhances=enhances,
             breaks=breaks,
+            built_using=built_using,
             essential=False,
             installedsize=100,
             architecturespecific=architecturespecific,