import koji

  from module_build_service import log, build_logs

  logging.basicConfig(level=logging.DEBUG)

  class KojiContentGenerator(object):

      """ Class for handling content generator imports of module builds into Koji """

      def _koji_rpms_in_tag(self, tag):

          """ Return the list of koji rpms in a tag. """

          log.debug("Listing rpms in koji tag %s", tag)

          try:

              rpms, builds = session.listTaggedRPMS(tag, latest=True)

                  }

              }

          }

          # Only add the CG build owner if the user exists in Koji

          if session.getUser(self.owner):

              ret[u'owner'] = self.owner

          """

          Tags the Content Generator build to module.cg_build_koji_tag.

          """

          tag_name = self.module.cg_build_koji_tag

          if not tag_name:

          a content generator based build

          Raises an exception when error is encountered during import"""

          file_dir = self._prepare_file_directory()

          metadata = self._get_content_generator_metadata(file_dir)

  from module_build_service.errors import ProgrammingError

  from module_build_service.builder.base import GenericBuilder

  logging.basicConfig(level=logging.DEBUG)

              weights[component_name] = weight

          return weights

          # Workaround koji specific code in modules.py

          return {"name": self.tag_name}

          """

          Creates the repository using "createrepo_c" command in the resultsdir.

          """

          pkglist_f.close()

          m1_mmd.set_rpm_artifacts(artifacts)

          execute_cmd(['/usr/bin/createrepo_c', '--pkglist', pkglist, path])

      def _add_repo(self, name, baseurl, extra=""):

          """

      def repo_from_tag(cls, config, tag_name, arch):

          pass

  class BaseBuilder(object):

      def __init__(self, config, resultsdir):

          """

          raise NotImplementedError()

      def finalize(self):

          """

          :return: None

              parent.transition(config, state=models.BUILD_STATES['failed'],

                                state_reason="Some components failed to build.")

              session.commit()

              return []

          elif not built_components_in_batch:

              # If there are no successfully built components in a batch, there is nothing to tag.

      get_rpm_release,

      generate_koji_tag)

  from module_build_service.errors import UnprocessableEntity, Forbidden, ValidationError

  from requests.exceptions import ConnectionError

              component.state = koji.BUILD_STATES['FAILED']

              component.state_reason = build.state_reason

              session.add(component)

      else:

          # Do not overwrite state_reason set by Frontend if any.

          if not build.state_reason:

      # Don't transition it again if it's already been transitioned

      if build.state != models.BUILD_STATES["failed"]:

          build.transition(config, state="failed")

      session.commit()

      build_logs.stop(build)

      module_build_service.builder.GenericBuilder.clear_cache(build)

          # This is ok.. it's a race condition we can ignore.

          pass

      build.transition(config, state="ready")

      session.commit()

          else:

              module_build.transition(config, state=models.BUILD_STATES['done'])

          session.commit()

      return further_work

                  component_build.module_build.koji_tag + '-build', component_build.package))

          return msgs

  def cleanup_moksha():

      # Necessary to restart the twisted reactor for the next test.

          except OSError:

              pass

      @patch("subprocess.Popen")

      @patch("subprocess.check_output", return_value='1.4')

      @patch("pkg_resources.get_distribution")

          rpms_in_tag.assert_called_once()

          assert expected_output == ret

      @patch("subprocess.Popen")

      @patch("subprocess.check_output", return_value='1.4')

      @patch("pkg_resources.get_distribution")

          with open(path.join(dir_path, "modulemd.txt")) as mmd:

              assert len(mmd.read()) == 1134

      def test_tag_cg_build(self, get_session):

          """ Test that the CG build is tagged. """

          koji_session = MagicMock()

          koji_session.getTag.assert_called_once_with(self.cg.module.cg_build_koji_tag)

          koji_session.tagBuild.assert_called_once_with(123, "nginx-0-2.10e50d06")

      def test_tag_cg_build_fallback_to_default_tag(self, get_session):

          """ Test that the CG build is tagged to default tag. """

          koji_session = MagicMock()

              call(conf.koji_cg_default_build_tag)]

          koji_session.tagBuild.assert_called_once_with(123, "nginx-0-2.10e50d06")

      def test_tag_cg_build_no_tag_set(self, get_session):

          """ Test that the CG build is not tagged when no tag set. """

          koji_session = MagicMock()

          koji_session.tagBuild.assert_not_called()

      def test_tag_cg_build_no_tag_available(self, get_session):

          """ Test that the CG build is not tagged when no tag available. """

          koji_session = MagicMock()

      def repo_from_tag(self, config, tag_name, arch):

          pass

  @patch("module_build_service.builder.GenericBuilder.default_buildroot_groups",

         return_value={'build': [], 'srpm-build': []})