Support multiple release streams in sync release jobs

packit_service/events/anitya/abstract.py

@@ -43,7 +43,7 @@ def __init__(
 
     @property
     @abstractmethod
-    def version(self) -> str: ...
+    def versions(self) -> list[str]: ...
 
     @cached_property
     def project(self) -> Optional[GitProject]:
@@ -63,33 +63,14 @@ def base_project(self):
 
     def _add_release_and_event(self):
         if not self._db_project_object or not self._db_project_event:
-            if not self.project_url:
-                (
-                    self._db_project_object,
-                    self._db_project_event,
-                ) = ProjectEventModel.add_anitya_version_event(
-                    version=self.version,
-                    project_name=self.anitya_project_name,
-                    project_id=self.anitya_project_id,
-                    package=self.package_name,
-                )
-                return
-
-            if not (self.tag_name and self.repo_name and self.repo_namespace and self.project_url):
-                logger.info(
-                    "Not going to create the DB project event, not valid arguments.",
-                )
-                return
-
             (
                 self._db_project_object,
                 self._db_project_event,
-            ) = ProjectEventModel.add_release_event(
-                tag_name=self.tag_name,
-                namespace=self.repo_namespace,
-                repo_name=self.repo_name,
-                project_url=self.project_url,
-                commit_hash=None,
+            ) = ProjectEventModel.add_anitya_multiple_versions_event(
+                versions=self.versions,
+                project_name=self.anitya_project_name,
+                project_id=self.anitya_project_id,
+                package=self.package_name,
             )
 
     @property
@@ -139,22 +120,25 @@ def repo_name(self) -> Optional[str]:
         return self.repo_url.repo if self.repo_url else None
 
     @property
-    def tag_name(self):
+    def tag_names(self) -> list[str]:
         if not (self.packages_config and self.packages_config.upstream_tag_template):
-            return self.version
+            return list(self.versions)
 
-        return self.packages_config.upstream_tag_template.format(
-            version=self.version,
-            upstream_package_name=self.packages_config.upstream_package_name,
-        )
+        return [
+            self.packages_config.upstream_tag_template.format(
+                version=version,
+                upstream_package_name=self.packages_config.upstream_package_name,
+            )
+            for version in self.versions
+        ]
 
     def get_dict(self, default_dict: Optional[dict] = None) -> dict:
         d = self.__dict__
         d["project_url"] = self.project_url
-        d["tag_name"] = self.tag_name
+        d["tag_names"] = self.tag_names
         d["repo_name"] = self.repo_name
         d["repo_namespace"] = self.repo_namespace
-        d["version"] = self.version
+        d["versions"] = self.versions
         result = super().get_dict(d)
         result.pop("project")
         result.pop("repo_url")

packit_service/events/anitya/update.py

@@ -2,7 +2,6 @@
 # SPDX-License-Identifier: MIT
 
 from logging import getLogger
-from typing import Optional
 
 from packit.config import JobConfigTriggerType
 
@@ -21,7 +20,7 @@ class NewHotness(AnityaUpdate):
     def __init__(
         self,
         package_name: str,
-        version: str,
+        versions: list[str],
         distgit_project_url: str,
         bug_id: int,
         anitya_project_id: int,
@@ -33,22 +32,22 @@ def __init__(
             anitya_project_id=anitya_project_id,
             anitya_project_name=anitya_project_name,
         )
-        self._version = version
+        self._versions = versions
         self.bug_id = bug_id
 
     @classmethod
     def event_type(cls) -> str:
         return "anitya.NewHotness"
 
     @property
-    def version(self) -> str:
-        return self._version
+    def versions(self) -> list[str]:
+        return self._versions
 
     @classmethod
     def from_event_dict(cls, event: dict) -> "NewHotness":
         return cls(
             package_name=event.get("package_name"),
-            version=event.get("version"),
+            versions=event.get("versions"),
             distgit_project_url=event.get("distgit_project_url"),
             bug_id=event.get("bug_id"),
             anitya_project_id=event.get("anitya_project_id"),
@@ -82,19 +81,16 @@ def event_type(cls) -> str:
         return "anitya.VersionUpdate"
 
     @property
-    def version(self) -> Optional[str]:
-        # we will decide the version just when syncing release
-        # (for the particular branch etc.),
-        # until that we work with all the new versions
-        return None
+    def versions(self) -> list[str]:
+        return self._versions
 
     def _add_release_and_event(self):
         if not self._db_project_object or not self._db_project_event:
             (
                 self._db_project_object,
                 self._db_project_event,
             ) = ProjectEventModel.add_anitya_multiple_versions_event(
-                versions=self._versions,
+                versions=self.versions,
                 project_name=self.anitya_project_name,
                 project_id=self.anitya_project_id,
                 package=self.package_name,

packit_service/events/event_data.py

@@ -7,7 +7,6 @@
 from typing import Optional
 
 from ogr.abstract import GitProject
-from ogr.parsing import RepoUrl
 
 from packit_service.config import ServiceConfig
 from packit_service.models import (
@@ -32,6 +31,7 @@ def __init__(
         event_id: int,
         project_url: str,
         tag_name: Optional[str],
+        tag_names: Optional[list[str]],
         git_ref: Optional[str],
         pr_id: Optional[int],
         commit_sha: Optional[str],
@@ -49,6 +49,7 @@ def __init__(
         self.event_id = event_id
         self.project_url = project_url
         self.tag_name = tag_name
+        self.tag_names = tag_names
         self.git_ref = git_ref
         self.pr_id = pr_id
         self.commit_sha = commit_sha
@@ -78,6 +79,7 @@ def from_event_dict(cls, event: dict):
         event_id = event.get("event_id")
         project_url = event.get("project_url")
         tag_name = event.get("tag_name")
+        tag_names = event.get("tag_names")
         git_ref = event.get("git_ref")
         # event has _pr_id as the attribute while pr_id is a getter property
         pr_id = event.get("_pr_id") or event.get("pr_id")
@@ -107,6 +109,7 @@ def from_event_dict(cls, event: dict):
             event_id=event_id,
             project_url=project_url,
             tag_name=tag_name,
+            tag_names=tag_names,
             git_ref=git_ref,
             pr_id=pr_id,
             commit_sha=commit_sha,
@@ -219,34 +222,14 @@ def _add_project_object_and_event(self):
         elif self.event_type in {
             "anitya.NewHotness",
         }:
-            if not self.project_url:
-                (
-                    self._db_project_object,
-                    self._db_project_event,
-                ) = ProjectEventModel.add_anitya_version_event(
-                    version=self.event_dict.get("version"),
-                    project_name=self.event_dict.get("anitya_project_name"),
-                    project_id=self.event_dict.get("anitya_project_id"),
-                    package=self.event_dict.get("package_name"),
-                )
-                return
-
-            if self.project:
-                namespace = self.project.namespace
-                repo_name = self.project.repo
-            else:
-                repo_url = RepoUrl.parse(self.project_url)
-                namespace = repo_url.namespace
-                repo_name = repo_url.repo
             (
                 self._db_project_object,
                 self._db_project_event,
-            ) = ProjectEventModel.add_release_event(
-                tag_name=self.tag_name,
-                namespace=namespace,
-                repo_name=repo_name,
-                project_url=self.project_url,
-                commit_hash=self.commit_sha,
+            ) = ProjectEventModel.add_anitya_multiple_versions_event(
+                versions=self.event_dict.get("versions"),
+                project_name=self.event_dict.get("anitya_project_name"),
+                project_id=self.event_dict.get("anitya_project_id"),
+                package=self.event_dict.get("package_name"),
             )
         elif self.event_type in {
             "github.issue.Comment",

packit_service/worker/checker/distgit.py

@@ -272,7 +272,7 @@ def pre_check(self) -> bool:
         valid = True
         msg_to_report = None
         issue_title = (
-            f"Pull from upstream could not be run for update {self.data.event_dict.get('version')}"
+            f"Pull from upstream could not be run for update {self.data.event_dict.get('versions')}"
         )
 
         if self.package_config.upstream_project_url and not (
@@ -286,9 +286,9 @@ def pre_check(self) -> bool:
             valid = False
 
         if self.package_config.upstream_project_url and (
-            self.data.event_type in (anitya.NewHotness.event_type(),) and not self.data.tag_name
+            self.data.event_type in (anitya.NewHotness.event_type(),) and not self.data.tag_names
         ):
-            msg_to_report = "We were not able to get the upstream tag name."
+            msg_to_report = "We were not able to get the upstream tag name(s)."
             valid = False
 
         if self.data.event_type in (pagure.pr.Comment.event_type(),):

packit_service/worker/checker/run_condition.py

@@ -5,6 +5,7 @@
 import logging
 import shutil
 import tempfile
+from functools import cmp_to_key
 from pathlib import Path
 from typing import Optional
 
@@ -18,6 +19,7 @@
 )
 from packit.config import JobConfig, PackageConfig
 from packit.exceptions import PackitCommandFailedError
+from packit.utils.versions import compare_versions
 from specfile import Specfile
 
 from packit_service.events import (
@@ -127,8 +129,18 @@ def pre_check(self) -> bool:
             elif self.data.event_type in (anitya.NewHotness.event_type(),):
                 event = anitya.NewHotness.from_event_dict(self.data.event_dict)
                 project = event.project
-                git_ref = event.tag_name
-                version = event.version
+                # FIXME: for now get the highest version (and tag), in the future the list
+                # of all versions should be presented to users as an environment variable
+                version = (
+                    max(event.versions, key=cmp_to_key(compare_versions))
+                    if event.versions
+                    else None
+                )
+                git_ref = (
+                    max(event.tag_names, key=cmp_to_key(compare_versions))
+                    if event.tag_names
+                    else None
+                )
             elif self.data.event_type in (
                 github.issue.Comment.event_type(),
                 gitlab.issue.Comment.event_type(),