# Written by Jan Kaluza <jkaluza@redhat.com>

  import json

  import kobo

  from freshmaker import conf, db

                      continue

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

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

                  if parent_nvr:

                      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

                  # it is included in a rebuild, it must be just a dependency of

                      rebuild_reason = RebuildReason.DEPENDENCY.value

                  build = self.record_build(

                      dep_on=dep_on,

                      state=ArtifactBuildState.PLANNED.value,

                      original_nvr=nvr,

          :rtype: bool

          :return: True when image should be filtered out.

          """

          if not self.event.is_allowed(

              self.log_info(

                  "Skipping rebuild of image %s, not allowed by configuration",

                  image.nvr)

      region = dogpile.cache.make_region().configure(conf.dogpile_cache_backend)

          if arch and rpm_manifest:

      @property

      def log_error(self, err):

          """

      def _get_additional_data_from_koji(self, nvr):

          """

          Finds the build defined by `nvr` in Koji and returns dict with

          "commit", "target" and "git_branch".

          In case of lookup error, the "error" will be set to error string.

          images = []

          nvr_to_arches = {}

          for image_data in response['processed']:

              images.append(image)

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

          if images:

              if parent_image:

              else:

                  # If we did not find the parent image with the package,

                  # we still want to set the parent of the last image with

                      log.error(err)

                      if not images[-1]['error']:

                          images[-1]['error'] = err

          if not parent_image:

              return images

                  if phase == "handle_parent_change":

                      # Find out the name of parent image of latest release image.

                      latest_image = nvr_to_image[latest_released_nvr]

                          continue

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

                      # update its parents according to latest image parents.

                      for nvr in nvrs[latest_released_nvr_index + 1:]:

                          image = nvr_to_image[nvr]

                              continue

                              for image_id, parent_id in nvr_to_coordinates[nvr]:

                                  latest_image_id, latest_parent_id = nvr_to_coordinates[latest_released_nvr][0]

                                  to_rebuild[image_id][parent_id:] = to_rebuild[latest_image_id][latest_parent_id:]

                              # the ["parent"] record for the child image to point to the image

                              # with highest NVR.

                              if parent_id != 0:

          return to_rebuild

          # included in different container repositories.

          repositories = image.get_registry_repositories(self)

          repository_key = sorted([r["repository"] for r in repositories])

      def _images_to_rebuild_to_batches(self, to_rebuild, directly_affected_nvrs):

          """

                  rebuild_list[srpm_name] = self.find_parent_images_with_package(

                      image, srpm_name, [])

                  if rebuild_list[srpm_name]:

                  else:

                      parent_brew_build = self.find_parent_brew_build_nvr_from_child(image)

                      if parent_brew_build:

                          if parent:

                              parent = parent[0]

                              parent.resolve(self, images)

                  rebuild_list[srpm_name].insert(0, image)

              return rebuild_list

              self.assertEqual(build.type, ArtifactType.IMAGE.value)

              image = images[build.original_nvr]

              else:

                  self.assertEqual(build.dep_on, None)

          self.patcher = helpers.Patcher(

              'freshmaker.lightblue.')

              '_id': '1233829',

              'brew': {

                  'completion_date': u'20170421T04:27:51.000-0400',

          self.koji_read_config_patcher.stop()

      def test_create(self):

              '_id': '1233829',

              'brew': {

                  'completion_date': '20151210T10:09:35.000-0500',

      def test_update_multi_arch(self):

          rpm_manifest_x86_64 = [{'rpms': [{'name': 'spam'}]}]

              '_id': '1233829',

              'architecture': 'amd64',

              'brew': {

          })

          rpm_manifest_s390x = [{'rpms': [{'name': 'maps'}]}]

              '_id': '1233829',

              'architecture': 's390x',

              'brew': {

          })

      def test_log_error(self):

              'brew': {

                  'build': 'package-name-1-4-12.10',

              },

              "Cannot resolve the container image: Expected exception.")

      def test_resolve_content_sets_already_included_in_lb_response(self):

              '_id': '1233829',

              'brew': {

                  'build': 'package-name-1-4-12.10',

                           "lightblue_container_image")

      def test_resolve_content_sets_no_repositories(self):

              '_id': '1233829',

              'brew': {

                  'build': 'package-name-1-4-12.10',

      @patch('freshmaker.kojiservice.KojiService.get_task_request')

      def test_resolve_content_sets_no_repositories_children_set(

              self, get_task_request, get_build):

              '_id': '1233829',

              'brew': {

                  'build': 'package-name-1-4-12.10',

          })

          self.assertTrue("content_sets" not in image)

              '_id': '1233828',

              'brew': {

                  'build': 'child1-name-1-4-12.10',

              },

          })

              '_id': '1233828',

              'brew': {

                  'build': 'child2-name-1-4-12.10',

          self.assertEqual(image["content_sets"], ["foo", "bar"])

      def test_resolve_content_sets_empty_repositories(self):

              '_id': '1233829',

              'brew': {

                  'build': 'package-name-1-4-12.10',

          self.assertEqual(image["content_sets"], [])

      def test_resolve_published(self):

              '_id': '1233829',

              'brew': {

                  'build': 'package-name-1-4-12.10',

              include_rpm_manifest=False)

      def test_resolve_published_unpublished(self):

              '_id': '1233829',

              'brew': {

                  'build': 'package-name-1-4-12.10',

          self.assertEqual(image["rpm_manifest"], "x")

      def test_resolve_published_not_image_in_lb(self):

              '_id': '1233829',

              'brew': {

                  'build': 'package-name-1-4-12.10',

          ]

          self.fake_container_images = [

              for data in self.fake_images_with_parsed_data]

          self.fake_container_images_floating_tag = [

              for data in self.fake_images_with_parsed_data_floating_tag]

          self.fake_images_with_modules = [

              for data in self.fake_images_with_modules]

          self.fake_container_images_with_parent_brew_build = [

              for data in self.fake_images_with_parent_brew_build]

          self.fake_koji_builds = [{"task_id": 654321}, {"task_id": 123456}]

          cont_repos.return_value = self.fake_repositories_with_content_sets

          # "filtered_x-1-23" image will be filtered by filter_fnc.

          cont_images.return_value = self.fake_container_images + [

                  {"content_sets": ["dummy-content-set-1"],

                   "brew": {"build": "filtered_x-1-23"},

                   "repositories": [

          # "filtered_x-1-23" image will be filtered by filter_fnc.

          cont_images.return_value = self.fake_container_images + [

                  {

                      "content_sets": ["dummy-content-set-1"],

                      "brew": {"build": "filtered_x-1-23"},

          # set, it will take the content_sets from the child image.

          images_without_repositories = []

          for data in self.fake_images_with_parsed_data:

              del img["repositories"]

              images_without_repositories.append(img)

          # set, it will take the content_sets from the child image.

          images_without_repositories = []

          for data in self.fake_images_with_parsed_data:

              del img["repositories"]

              images_without_repositories.append(img)

                                 find_images_with_packages_from_content_set):

          exists.return_value = True

              'brew': {'package': 'image-a', 'build': 'image-a-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-a-commit'

          })

              'brew': {'package': 'image-b', 'build': 'image-b-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-b-commit',

              'parent': image_a,

          })

              'brew': {'package': 'image-c', 'build': 'image-c-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-c-commit',

              'parent': image_b,

          })

              'brew': {'package': 'image-e', 'build': 'image-e-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-e-commit',

              'parent': image_a,

          })

              'brew': {'package': 'image-d', 'build': 'image-d-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-d-commit',

              'parent': image_e,

          })

              'brew': {'package': 'image-j', 'build': 'image-j-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-j-commit',

              'parent': image_e,

          })

              'brew': {'package': 'image-k', 'build': 'image-k-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-k-commit',

              'parent': image_j,

          })

              'brew': {'package': 'image-g', 'build': 'image-g-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'image-g-commit',

              'parent': None,

          })

              'brew': {'package': 'image-f', 'build': 'image-f-v-r1'},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'parent': image_g,

          })

              'brew': {'build': 'leaf-image-1-1'},

              'parsed_data': {'layers': ['fake layer']},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'leaf-image1-commit',

          })

              'brew': {'build': 'leaf-image-2-1'},

              'parsed_data': {'layers': ['fake layer']},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'leaf-image2-commit',

          })

              'brew': {'build': 'leaf-image-3-1'},

              'parsed_data': {'layers': ['fake layer']},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'leaf-image3-commit',

          })

              'brew': {'build': 'leaf-image-4-1'},

              'parsed_data': {'layers': ['fake layer']},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'leaf-image4-commit',

          })

              'brew': {'build': 'leaf-image-5-1'},

              'parsed_data': {'layers': ['fake layer']},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'leaf-image5-commit',

          })

              'brew': {'build': 'leaf-image-6-1'},

              'parsed_data': {'layers': ['fake layer']},

              'repositories': [{"repository": "foo/bar"}],

              'repository': 'repo-1',

              'commit': 'leaf-image6-commit',

          })

              'brew': {'build': 'leaf-image-7-1'},

              'parsed_data': {'layers': ['fake layer']},

              'repositories': [{'repository': 'foo/bar'}],

          find_images_with_packages_from_content_set.return_value = images

          leaf_image6_as_parent = copy.deepcopy(leaf_image6)

          # When the image is a parent, directly_affected is not set

          del leaf_image6_as_parent["directly_affected"]

          find_parent_images_with_package.side_effect = [

              find_images_with_packages_from_content_set, cont_images):

          exists.return_value = True

              "brew": {"package": "image-a", "build": "image-a-v-r1"},

              "parent_brew_build": "some-original-nvr-7.6-252.1561619826",

              "repository": "repo-1",

              }]

          }

          dependency_ubi_image_data = copy.deepcopy(ubi_image_template)

          dependency_ubi_image_nvr = directly_affected_ubi_image.nvr + ".12345678"

          dependency_ubi_image_data["brew"]["build"] = dependency_ubi_image_nvr

          # A dependecy image is not directly published

          dependency_ubi_image_data["repositories"] = []

              "brew": {"package": "python-36-container", "build": "python-36-container-1-10"},

              "parent_brew_build": directly_affected_ubi_image.nvr,

              "parent_image_builds": {},

              }]

          })

              "brew": {"package": "nodejs-12-container", "build": "nodejs-12-container-1-20.45678"},

              "parent_brew_build": dependency_ubi_image.nvr,

              "repository": "containers/nodejs-12",

                  'architecture': 's390x'

              }

          ]

          find_repos.return_value = self.fake_repositories_with_content_sets

          find_images.return_value = self.fake_container_images + new_images

          right_content_sets = [["dummy-content-set-1"],

          repositories = {

              repo["repository"]: repo for repo in

              self.fake_repositories_with_content_sets}

              "brew": {"build": "parent-1-2"}, "repositories": repos,

              "content_sets": ["dummy-content-set-1"]})

              "brew": {"build": "parent-1-3"}, "repositories": repos,

              "content_sets": ["dummy-content-set-1"]})

              "brew": {"build": "parent-1-1"}, "repositories": repos,

              "content_sets": ["dummy-content-set-2"]})

          cont_images.return_value = [parent, latest_parent, older_parent]

          self.os_path_exists_patcher.stop()

      def _create_img(self, nvr):

              'brew': {'build': nvr},

              'content_sets': [],

              'content_sets_source': 'distgit',

              else:

                  image = self._create_img(data)

              if images:

              images.append(image)

          return images

              u'summary': u'Java logging toolkit',

              u'version': u'2.1'

          }]}]

              u'arches': arches,  # Populated based on Brew build

              u'architecture': architecture,  # Populated from Lightblue data

              u'rpm_manifest': rpm_manifest,