# the ArtifactBuild is created.

                  self.set_context(db_event)

                  if nvr in builds:

                      self.log_debug("Skipping recording build %s, "

                                     "it is already in db", nvr)

                      continue

                  self.log_debug("Recording %s", nvr)

                      if "parent" in image and image["parent"] else None

                  dep_on = builds[parent_nvr] if parent_nvr in builds else None

                      state_reason = ""

                      state = ArtifactBuildState.PLANNED.value

                  # Only released images are considered as directly affected for

                  # rebuild. If some image is not in the latest released version and

          :return: True when image should be filtered out.

          """

          if not self.event.is_allowed(

                  self, image_name=parsed_nvr["name"],

                  image_version=parsed_nvr["version"],

                  image_release=parsed_nvr["release"]):

              return True

          return False

          if not image["content_sets"]:

              raise ValueError(

                  "Found image \"%s\" in this repository, but it cannot be rebuilt, because "

      def _get_repository_from_name(self, repo_name):

          """

          self._verify_image_data(image)

          return {

          }

      def verify_repository(self, repo_name):

          images = self.lb.find_images_with_included_srpms(

              [], [], {repo["repository"]: repo}, include_rpm_manifest=False)

          for image in images:

              self._verify_image_data(image)

          if not rebuildable_images:

              raise ValueError(

              non-x86_64 image, OSBS will generate the Pulp repos and therefore

              we don't need content_sets in Freshmaker.

          """

          data = {"generate_pulp_repos": False,

                  "content_sets": []}

          Sets the "repository and "commit" keys/values if available.

          """

          # Find the additional data for Container build in Koji.

          try:

          except KojiLookupError as e:

              log.error(err)

              data = self._get_default_additional_data()

              data["error"] = err

          :param LightBlue lb_instance: LightBlue instance to use for additional

              queries.

          """

          data = self._get_additional_data_from_distgit(

              self["repository"], self["git_branch"], self["commit"])

              self["content_sets"] = data["content_sets"]

              self["content_sets_source"] = "distgit"

              log.info("Container image %s uses following content sets: %r",

              return

          # ContainerImage now has content_sets field, so use it if available.

          if "content_sets" in self and self["content_sets"]:

              log.info("Container image %s uses following content sets: %r",

              if "content_sets_source" not in self:

                  self["content_sets_source"] = "lightblue_container_image"

              return

          if not children:

              log.warning("Container image %s does not have 'content_sets' set "

                          "in Lightblue and also does not have any children, "

              self.update({"content_sets": []})

              return

              log.info("Container image %s does not have 'content-sets' set "

                       "in Lightblue. Using child image %s content_sets: %r",

                       child["content_sets"])

              self.update({"content_sets": child["content_sets"]})

              return

          log.warning("Container image %s does not have 'content_sets' set "

                      "in Lightblue as well as its children, this "

          self.update({"content_sets": []})

      def resolve_published(self, lb_instance):

          # Get the published version of this image to find out if the image

          # was actually published.

          images = lb_instance.get_images_by_nvrs(

          if images:

              self["published"] = True

          else:

              # to check for possible unpublished RPMs.

              # We do not want to get the complete manifest for every container

              # image, because it is relatively big, so fetch it only when needed.

              if images:

                  self["rpm_manifest"] = images[0]["rpm_manifest"]

              else:

      def resolve(self, lb_instance, children=None):

          """

              # TODO: In the future, we may want to combine different ContainerImage

              # objects into a single object. For now, ensure that whichever object

              # is used by caller contains multi-arch information.

              nvr_to_arches.setdefault(nvr, [])

              nvr_to_arches[nvr].append(image)

              for arch_image in nvr_to_arches[nvr][:-1]:

                  # In our case, this means that we filtered out the image.

                  log.info("Will not rebuild %s, because it does not contain "

                           "older version of any input package: %r" % (

          return ret

      def filter_out_modularity_mismatch(self, images, srpm_name_to_nvrs):

                  log.info(

                      "Will not rebuild %s because there is a modularity mismatch between the RPMs "

                      "from the image and the advisory: %r" % (

          return ret

      def filter_out_images_based_on_content_set(self, images, content_sets):

          # for now.

          image_nvr_to_image = {}

          for image in images:

              if nvr in image_nvr_to_image:

                  # This image for another architecture has already been seen

                  continue

          if not latest_parent or "repositories" not in latest_parent:

              return latest_parent

          for repo in latest_parent["repositories"]:

              repo_data = self.get_repository_from_name(repo["repository"])

                  #   - nvr1 newer than nvr2: 1

                  #   - same nvrs: 0

                  #   - nvr1 older: -1

                  if (parsed_nvr["name"] == latest_parent_nvr["name"] and

                          parsed_nvr["version"] == latest_parent_nvr["version"] and

                          kobo.rpmlib.compare_nvr(

                              latest_parent_nvr, parsed_nvr, ignore_epoch=True) == -1):

                      latest_parent = possible_latest_parent

          return latest_parent

              # Constructs the temporary dicts as described above.

              for image_id, images in enumerate(to_rebuild):

                  for parent_id, image in enumerate(images):

                      # Also include the sorted names of repositories in the image group

                      # to handle the case when different releases of single name-version are

                      # included in different container repositories.

                      if "parent" not in latest_image or not latest_image["parent"]:

                          continue

                      latest_parent_name = koji.parse_NVR(

                      # Go through the older images and in case the parent image differs,

                      # update its parents according to latest image parents.

                          image = nvr_to_image[nvr]

                          if "parent" not in image or not image["parent"]:

                              continue

                          if parent_name != latest_parent_name:

                              for image_id, parent_id in nvr_to_coordinates[nvr]:

                                  latest_image_id, latest_parent_id = nvr_to_coordinates[latest_released_nvr][0]

          seen = set()

          for image_rebuild_list in sorted(to_rebuild, key=lambda lst: len(lst), reverse=True):

              for image, batch in zip(reversed(image_rebuild_list), batches):

                  # If one of the parents is directly affected but not marked, mark it explicitly

                  if image_key in directly_affected_nvrs and not image.get("directly_affected"):

                      image["directly_affected"] = True

          # Get all the directly affected images so that any parents that are not marked as

          # directly affected can be set in _images_to_rebuild_to_batches

          directly_affected_nvrs = {

          }

          # Now generate batches from deduplicated list and return it.

          return self._images_to_rebuild_to_batches(to_rebuild, directly_affected_nvrs)

                             security_impact="None",

                             product_short_name="product"))

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, False)

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, False)

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, False)

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, True)

                             security_impact="None",

                             product_short_name="product"))

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, False)

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, True)

                             security_impact="None",

                             product_short_name="product"))

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, False)

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, False)

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, True)

          ret = handler._filter_out_not_allowed_builds(image)

          self.assertEqual(ret, True)

      def _mock_build(

              self, build, parent=None, error=None, **kwargs):

          if parent:

          d = {

              'brew': {'build': build + "-1-1.25"},

              'repository': build + '_repo',

          images = {}

          for batch in batches:

              for image in batch:

          # Record the batches.

          event = events.BrewSignRPMEvent("123", "openssl-1.1.0-1")

  from unittest.mock import MagicMock

  from freshmaker.image_verifier import ImageVerifier

  from tests import helpers

              self.verifier.verify_repository, "foo/bar")

      def test_verify_repository_no_content_sets(self):

          self.assertRaisesRegex(

              ValueError, r'.*are not set for this image.',

              self.verifier.verify_repository, "foo/bar")

      def test_verify_repository(self):

          ret = self.verifier.verify_repository("foo/bar")

          self.assertEqual(ret, {"foo-1-1": ["content-set"]})

      def test_get_verify_image(self):

          ret = self.verifier.verify_image("foo-1-1")

          self.assertEqual(ret, {"foo-1-1": ["content-set"]})

              ["dummy-content-set-1", "dummy-content-set-2"], ["openssl-1.2.3-2"], repositories)

          self.assertEqual(

              ['package-name-2-4-12.10', 'package-name-3-4-12.10'])

      @patch('freshmaker.lightblue.LightBlue.find_container_images')

              ["dummy-content-set-1", "dummy-content-set-2"],

              ["openssl-1.2.3-1", "openssl-1.2.3-50"], repositories)

          self.assertEqual(

              ['package-name-2-4-12.10', 'package-name-3-4-12.10'])

      def _filter_fnc(self, image):

      @patch('freshmaker.lightblue.LightBlue.find_container_repositories')

      @patch('freshmaker.lightblue.LightBlue.find_container_images')

              [leaf_image3]

          ]

          expected_batches_nvrs = [

              for batch in expected_batches

          ]

          returned_batches_nvrs = [

              for batch in batches

          ]

          # find_images_with_packages_from_content_set.

          for batch in batches:

              for image in batch:

                      self.assertTrue(leaf_image6_as_parent["directly_affected"])

                      break

                         cert=self.fake_cert_file,

                         private_key=self.fake_private_key)

          image = lb.find_latest_parent_image("foo", 1)

      @patch('freshmaker.lightblue.LightBlue.find_container_images')

      @patch('os.path.exists')

          ret = lb.find_images_with_included_srpms(

              ["dummy-content-set-1", "dummy-content-set-2"], ["openssl-1.2.3-2.module+el8.0.0+3248+9d514f3b.src"], repositories)

          self.assertEqual(

              ["package-name-3-4-12.10"])

          ret = lb.find_images_with_included_srpms(

              ["dummy-content-set-1", "dummy-content-set-2"], ["openssl-1.2.3-2.el8.0.0+3248+9d514f3b.src"], repositories)

          self.assertEqual(

              [])

      @patch('freshmaker.lightblue.LightBlue.find_container_images')

          ret = lb.find_images_with_included_srpms(

              ["dummy-content-set-1"], ["openssl-1.2.3-2.module+el8.0.0+3248+9d514f3b.src"], repositories)

          self.assertEqual(

              ["parent-1-2", "parent-1-3"])

          ])

          to_rebuild = [httpd, perl]

          batches = self.lb._images_to_rebuild_to_batches(to_rebuild, set())

          # Both perl and httpd share the same parent images, so include

          # just httpd's one in expected batches - they are the same as

              to_rebuild.append(deps[i:])

          batches = self.lb._images_to_rebuild_to_batches(to_rebuild, {httpd_nvr})

          # We expect each image to be rebuilt just once.

          expected = [[deps[3]], [deps[2]], [deps[1]], [deps[0]]]

          self.assertEqual(batches, expected)

          for batch in batches:

              for image in batch:

                      self.assertTrue(image['directly_affected'])

                  else:

                      self.assertFalse(image.get('directly_affected'))