builds: Fix fetching reverse requires

Signed-off-by: Michael Tremer <michael.tremer@ipfire.org>

diff --git a/src/buildservice/builds.py b/src/buildservice/builds.py
index 6a8e86acd8bda01287a35e6662dbcd4f346aae84..f1c3365bf64f4cd7b985ed81661f3688793075d9 100644 (file)
--- a/src/buildservice/builds.py
+++ b/src/buildservice/builds.py
@@ -15,6 +15,7 @@ from sqlalchemy import Boolean, DateTime, Integer, Text, UUID
 from . import base
 from . import builds
 from . import database
+from . import jobs
 from . import packages
 from . import repos
 from . import users
@@ -214,40 +215,51 @@ class Builds(base.Object):
 
                return self.db.fetch(stmt)
 
-       def get_by_package_uuids(self, uuids):
+       async def get_by_package_uuids(self, uuids):
                """
                        Returns a list of builds that contain the given packages
                """
-               return self._get_builds("""
-                       SELECT
-                               DISTINCT builds.*
-                       FROM
-                               builds
-                       LEFT JOIN
-                               packages source_packages ON builds.pkg_id = source_packages.id
-                       LEFT JOIN
-                               jobs ON builds.id = jobs.build_id
-                       LEFT JOIN
-                               job_packages ON jobs.id = job_packages.job_id
-                       LEFT JOIN
-                               packages ON job_packages.pkg_id = packages.id
-                       WHERE
-                               builds.deleted_at IS NULL
-                       AND
-                               jobs.deleted_at IS NULL
-                       AND
-                               source_packages.deleted_at IS NULL
-                       AND
-                               packages.deleted_at IS NULL
-                       AND
-                               (
-                                       packages.uuid = ANY(%s::uuid[])
-                               OR
-                                       source_packages.uuid = ANY(%s::uuid[])
-                               )
-                       """, uuids, uuids,
+               source_packages = sqlalchemy.orm.aliased(packages.Package)
+               binary_packages = sqlalchemy.orm.aliased(packages.Package)
+
+               stmt = (
+                       sqlalchemy
+                       .select(
+                               Build,
+                       )
+                       .distinct()
+                       .join(
+                               source_packages,
+                               source_packages.id == Build.pkg_id,
+                       )
+                       .join(
+                               jobs.Job,
+                               jobs.Job.build_id == Build.id,
+                       )
+                       .join(
+                               jobs.JobPackage,
+                               jobs.JobPackage.job_id == jobs.Job.id,
+                       )
+                       .join(
+                               binary_packages,
+                               binary_packages.id == jobs.JobPackage.pkg_id,
+                       )
+                       .where(
+                               Build.deleted_at == None,
+                               jobs.Job.deleted_at == None,
+                               source_packages.deleted_at == None,
+                               binary_packages.deleted_at == None,
+                       )
+                       .where(
+                               sqlalchemy.or_(
+                                       source_packages.uuid.in_(uuids),
+                                       binary_packages.uuid.in_(uuids),
+                               ),
+                       )
                )
 
+               return await self.db.fetch_as_set(stmt)
+
        async def create(self, repo, package, owner=None, group=None, test=False,
                        disable_test_builds=False, timeout=None):
                """
@@ -1106,10 +1118,8 @@ class Build(database.Base, database.BackendMixin, database.SoftDeleteMixin):
                """
                log.debug("Calculating reverse requires for %s..." % self)
 
-               # Collect the builds from all jobs
-               reverse_requires = await asyncio.gather(
-                       *(job._reverse_requires() for job in self.jobs),
-               )
+               # Fetch reverse requires for all jobs
+               reverse_requires = [await job._reverse_requires() for job in self.jobs]
 
                # Join all builds together
                return itertools.chain(*reverse_requires)

diff --git a/src/buildservice/jobs.py b/src/buildservice/jobs.py
index 5adf9925c6516e596ec40e87e2283dfa73d64771..b3785df005dfcfbd0304cfff74d1dd8d17a6a99a 100644 (file)
--- a/src/buildservice/jobs.py
+++ b/src/buildservice/jobs.py
@@ -1219,4 +1219,4 @@ class Job(database.Base, database.BackendMixin, database.SoftDeleteMixin):
                        return []
 
                # Return any builds that generated those packages
-               return self.backend.builds.get_by_package_uuids(packages)
+               return await self.backend.builds.get_by_package_uuids(packages)

diff --git a/src/scripts/pakfire-build-service b/src/scripts/pakfire-build-service
index f33a1825df6105e0c5736f7c000104b1eb578caf..5a06c17755e2864c51f606277fbf36de5463b65b 100644 (file)
--- a/src/scripts/pakfire-build-service
+++ b/src/scripts/pakfire-build-service
@@ -136,7 +136,7 @@ class Cli(object):
 
        async def _builds_reverse_requires(self, *uuids):
                for uuid in uuids:
-                       build = self.backend.builds.get_by_uuid(uuid)
+                       build = await self.backend.builds.get_by_uuid(uuid)
                        if not build:
                                log.error("Could not find build %s" % uuid)
                                continue