# Written by Stanislav Ochotnicky <sochotnicky@redhat.com>

  #            Jan Kaluza <jkaluza@redhat.com>

  import calendar

  import hashlib

  import logging

  from module_build_service import conf, log, build_logs, Modulemd, glib

  from module_build_service.scm import SCM

  logging.basicConfig(level=logging.DEBUG)

          self.owner = module.owner

          self.module = module

          self.module_name = module.name

          self.config = config

          self.devel = False

          # List of architectures the module is built for.

          mmd_path = os.path.join(output_path, mmd_filename)

          try:

              with open(mmd_path, 'rb') as mmd_f:

                  mmd = Modulemd.Module().new_from_string(data)

                  ret['filename'] = mmd_filename

                  ret['filesize'] = len(data)

          # Fill in the list of built RPMs.

          mmd = self._fill_in_rpms_list(mmd, arch)

      def _download_source_modulemd(self, mmd, output_path):

          """

          prepdir = tempfile.mkdtemp(prefix="koji-cg-import")

          mmd_path = os.path.join(prepdir, "modulemd.txt")

          log.info("Writing generic modulemd.yaml to %r" % mmd_path)

              mmd_f.write(self.mmd)

          mmd_path = os.path.join(prepdir, "modulemd.src.txt")

              mmd_path = os.path.join(prepdir, "modulemd.%s.txt" % arch)

              log.info("Writing %s modulemd.yaml to %r" % (arch, mmd_path))

              mmd = self._finalize_mmd(arch)

                  mmd_f.write(mmd)

          log_path = os.path.join(prepdir, "build.log")

  from module_build_service.utils.ursine import handle_stream_collision_modules

  from requests.exceptions import ConnectionError

  import koji

          record_component_builds(mmd, build, session=session)

          handle_stream_collision_modules(mmd)

          mmd = record_filtered_rpms(mmd)

          build.transition(conf, models.BUILD_STATES["wait"])

      # Catch custom exceptions that we can expose to the user

      except (UnprocessableEntity, Forbidden, ValidationError, RuntimeError) as e:

  import hashlib

  import time

  from datetime import datetime

  from module_build_service import conf, log, models

  from module_build_service.errors import (

      ValidationError, ProgrammingError, UnprocessableEntity)

  def scm_url_schemes(terse=False):

      """

      Definition of URL schemes supported by both frontend and scheduler.

      build.version = version

      build.koji_tag = koji_tag

      build.state = models.BUILD_STATES['ready']

      build.context = context

      build.owner = "mbs_import"

      build.rebuild_strategy = 'all'

  import os

  from multiprocessing.dummy import Pool as ThreadPool

  from datetime import datetime

  import kobo.rpmlib

  import requests

                  name=mmd.get_name(),

                  stream=mmd.get_stream(),

                  version=version_str,

                  scmurl=url,

                  username=username,

                  **(optional_params or {})

              stream=mmd.get_stream(),

              version=str(mmd.get_version()),

              context=mmd.get_context(),

              scmurl="",

              username="mbs",

              publish_msg=False)

  import time

  import hashlib

  from traceback import extract_stack

  import koji

  import module_build_service

      if not os.path.exists(filename):

          raise ValueError('Staged data {}.yaml does not exist.'.format(yaml_name))

      with open(filename, 'r') as mmd:

  def patch_config():

                  build_one.ref_build_context = unique_hash

                  combined_hashes = '{0}:{1}'.format(unique_hash, unique_hash)

                  build_one.context = hashlib.sha1(combined_hashes.encode("utf-8")).hexdigest()[:8]

              build_one.koji_tag = 'module-nginx-1.2'

              build_one.scmurl = ('git://pkgs.domain.local/modules/nginx?'

                                  '#ba95886c7a443b36a9ce31abda1f9bef22f2f8c9')

      build_one.time_submitted = datetime(2017, 2, 15, 16, 8, 18)

      build_one.time_modified = datetime(2017, 2, 15, 16, 19, 35)

      build_one.rebuild_strategy = 'changed-and-after'

      build_one_component_release = get_rpm_release(build_one)

      build_one.buildrequires.append(platform_br)

      xmd['mbs']['scmurl'] = build_one.scmurl

      xmd['mbs']['commit'] = 'ff1ea79fc952143efeed1851aa0aa006559239ba'

      mmd.set_xmd(glib.dict_values(xmd))

      build_one.buildrequires.append(platform_br)

      component_one_build_one = module_build_service.models.ComponentBuild()

      xmd['mbs']['scmurl'] = build_one.scmurl

      xmd['mbs']['commit'] = '55f4a0a2e6cc255c88712a905157ab39315b8fd8'

      mmd.set_xmd(glib.dict_values(xmd))

      build_two.buildrequires.append(platform_br)

      component_one_build_two = module_build_service.models.ComponentBuild()

          build_one.build_context = 'e046b867a400a06a3571f3c71142d497895fefbe'

          build_one.runtime_context = '50dd3eb5dde600d072e45d4120e1548ce66bc94a'

          build_one.state = BUILD_STATES['ready']

          build_one.koji_tag = 'module-shared-userspace-f26-20170601141014-75f92abb'

          build_one.scmurl = ('https://src.stg.fedoraproject.org/modules/testmodule.'

                              'git?#7fea453')

          build_one.build_context = 'e046b867a400a06a3571f3c71142d497895fefbe'

          build_one.runtime_context = '50dd3eb5dde600d072e45d4120e1548ce66bc94a'

          build_one.state = BUILD_STATES['done']

          build_one.koji_tag = 'module-shared-userspace-f26-20170605091544-75f92abb'

          build_one.scmurl = ('https://src.stg.fedoraproject.org/modules/testmodule.'

                              'git?#7fea453')

      mmd.set_version(int(version))

      mmd.set_context(context)

      mmd.set_summary("foo")

      licenses = Modulemd.SimpleSet()

      licenses.add("GPL")

      mmd.set_module_licenses(licenses)

      module_build.build_context = context

      module_build.stream_build_context = context

      module_build.runtime_context = context

      if base_module:

          module_build.buildrequires.append(base_module)

      if 'koji_tag' in xmd['mbs']:

      version: 5

      summary: A fake module containing the bash shell

      description: >

      license:

          module:

              - MIT

  data:

      summary: A fake module containing the bash shell

      description: >

      license:

          module:

              - MIT

          Programmers can write new built-in modules for Python in C or C++.

          Python can be used as an extension language for applications that

      license:

          module:

              - MIT

    context: 9c690d0e

    summary: A test module in all its beautiful beauty

    description: This module demonstrates how to write simple modulemd files And can

    license:

      module:

      - MIT

    context: 9c690d0e

    summary: A test module in all its beautiful beauty

    description: This module demonstrates how to write simple modulemd files And can

    license:

      module:

      - MIT

  data:

      summary: A fake module containing the bash shell

      description: >

      license:

          module:

              - MIT

      summary: An example nginx module

      # A verbose description of the module, required

      description: >

      # Module and content licenses in the Fedora license identifier

      # format, required

      license:

  document: modulemd

  version: 1

  data:

    name: platform

    license:

      module: [MIT]

          Programmers can write new built-in modules for Python in C or C++.

          Python can be used as an extension language for applications that

      license:

          module:

              - MIT

      summary: A test module in all its beautiful beauty

      description: >-

          This module demonstrates how to write simple modulemd files And

      license:

          module: [ MIT ]

      dependencies:

    summary: A test module in all its beautiful beauty

    description: >-

      This module demonstrates how to write simple modulemd files And can be used for

    license:

      module:

      - MIT

      summary: A test module in all its beautiful beauty

      description: >-

          This module demonstrates how to write simple modulemd files And

      license:

          module: [ MIT ]

      dependencies:

  version: 1

  data:

      summary: A test module in all its beauty

      version: 0123456789

      license:

          module: [ MIT ]

      summary: A test module in all its beautiful beauty

      description: >-

          This module demonstrates how to write simple modulemd files And

      license:

          module: [ MIT ]

      dependencies:

  data:

      stream: wrong_stream

      summary: A test module in all its beauty

      license:

          module: [ MIT ]

      dependencies:

      summary: A test module in all its beautiful beauty

      description: >-

          This module demonstrates how to write simple modulemd files And

      license:

          module: [ MIT ]

      dependencies:

        silly: puddy

        glass: water

    description: This module demonstrates how to write simple modulemd files And can

    filter: {}

    license:

      module: [MIT]

      summary: A test module in all its beautiful beauty

      description: >-

          This module demonstrates how to write simple modulemd files And

      license:

          module: [ MIT ]

      dependencies:

    summary: A test module in all its beautiful beauty

    description: >-

      This module demonstrates how to write simple modulemd files And can be used for

    license:

      module:

      - MIT

    summary: A test module in all its beautiful beauty

    description: >-

      This module demonstrates how to write simple modulemd files And can be used for

    license:

      module:

      - MIT

    summary: A test module in all its beautiful beauty

    description: >-

      This module demonstrates how to write simple modulemd files And can be used for

    license:

      module:

      - MIT

  from shutil import copyfile

  from datetime import datetime, timedelta

  from random import randint

  import module_build_service.messaging

  import module_build_service.scheduler.handlers.repos

          testmodule = os.path.join(base_dir, 'staged_data', 'testmodule.yaml')

          with open(testmodule) as f:

          with patch.object(module_build_service.config.Config, 'yaml_submit_allowed',

                            new_callable=PropertyMock, return_value=False):

          formatted_testmodule_yml_path = os.path.join(

              current_dir, '..', 'staged_data', 'formatted_testmodule.yaml')

          with open(formatted_testmodule_yml_path, 'r') as f:

          build_one.koji_tag = 'module-testmodule-master-20180205135154-9c690d0e'

          build_one.scmurl = 'https://src.stg.fedoraproject.org/modules/testmodule.git?#7fea453'

          build_one.batch = 2

          formatted_testmodule_yml_path = os.path.join(

              current_dir, '..', 'staged_data', 'formatted_testmodule.yaml')

          with open(formatted_testmodule_yml_path, 'r') as f:

          build_one.koji_tag = 'module-testmodule-master-20180205135154-6ef9a711'

          build_one.scmurl = 'https://src.stg.fedoraproject.org/modules/testmodule.git?#7fea453'

          build_one.batch = 2

  except ImportError:

      import xmlrpc.client as xmlrpclib

  from collections import OrderedDict

  import module_build_service.messaging

  import module_build_service.scheduler.handlers.repos

              xmd = glib.from_variant_dict(mmd.get_xmd())

              xmd["mbs_options"] = {"blocked_packages": ["foo", "bar", "new"]}

              mmd.set_xmd(glib.dict_values(xmd))

          builder = FakeKojiModuleBuilder(owner=self.module.owner,

                                          module=self.module,

              xmd = glib.from_variant_dict(mmd.get_xmd())

              xmd["mbs_options"] = {"blocked_packages": ["foo", "nginx"]}

              mmd.set_xmd(glib.dict_values(xmd))

          if custom_whitelist:

              mmd = self.module.mmd()

              opts = mmd.get_buildopts()

              opts.set_rpm_whitelist(['custom1', 'custom2'])

              mmd.set_buildopts(opts)

          if repo_include_all is False:

              mmd = self.module.mmd()

              mbs_options["repo_include_all"] = False

              xmd["mbs_options"] = mbs_options

              mmd.set_xmd(glib.dict_values(xmd))

          if override_arches:

              mmd = self.module.mmd()

              mbs_options["buildrequires"] = {"platform": {"stream": "xx"}}

              xmd["mbs"] = mbs_options

              mmd.set_xmd(glib.dict_values(xmd))

          builder = FakeKojiModuleBuilder(

              owner=self.module.owner, module=self.module, config=conf, tag_name='module-foo',

              xmd = glib.from_variant_dict(mmd.get_xmd())

              xmd["mbs_options"] = {"blocked_packages": ["foo", "nginx"]}

              mmd.set_xmd(glib.dict_values(xmd))

          builder = FakeKojiModuleBuilder(

              owner=self.module.owner, module=self.module, config=conf, tag_name='module-foo',

  import tempfile

  import shutil

  from textwrap import dedent

  import kobo.rpmlib

              name="mbs-testmodule",

              stream="test",

              version="20171027111452",

              scmurl="file:///testdir",

              username="test",

          )

  # Written by Stanislav Ochotnicky <sochotnicky@redhat.com>

  #            Jan Kaluza <jkaluza@redhat.com>

  import pytest

  import json

  import os

  from os import path

  import module_build_service.messaging

  import module_build_service.scheduler.handlers.repos # noqa

      def test_prepare_file_directory(self):

          """ Test preparation of directory with output files """

          dir_path = self.cg._prepare_file_directory()

      def test_prepare_file_directory_per_arch_mmds(self):

          """ Test preparation of directory with output files """

          self.cg.arches = ["x86_64", "i686"]

          dir_path = self.cg._prepare_file_directory()

      @patch.dict("sys.modules", krbV=Mock())

      @patch("module_build_service.builder.KojiModuleBuilder.KojiClientSession")

      @patch("module_build_service.builder.KojiContentGenerator.open", create=True)

      def test_get_arch_mmd_output(self, patched_open):

          patched_open.return_value = mock_open(

          ret = self.cg._get_arch_mmd_output("./fake-dir", "x86_64")

          assert ret == {

              'arch': 'x86_64',

              'buildroot_id': 1,

              'checksum_type': 'md5',

              'components': [],

              'extra': {'typeinfo': {'module': {}}},

              'filename': 'modulemd.x86_64.txt',

              'type': 'file'

          }

          rpm_artifacts = mmd.get_rpm_artifacts()

          rpm_artifacts.add("dhcp-libs-12:4.3.5-5.module_2118aef6.x86_64")

          mmd.set_rpm_artifacts(rpm_artifacts)

          patched_open.return_value = mock_open(

              read_data=mmd_data).return_value

          assert ret == {

              'arch': 'x86_64',

              'buildroot_id': 1,

              'checksum_type': 'md5',

              'components': [{u'arch': 'x86_64',

                              u'epoch': '12',

                              u'version': '4.3.5'}],

              'extra': {'typeinfo': {'module': {}}},

              'filename': 'modulemd.x86_64.txt',

              'type': 'file'

          }

                  component.set_multilib(multilib_set)

              mmd.add_rpm_component(component)

      @pytest.mark.parametrize("devel", (False, True))

      def test_fill_in_rpms_list(self, devel):

          mmd.set_xmd(glib.dict_values({"mbs": {

              "commit": "foo",

              "scmurl": "git://localhost/modules/foo.git#master"}}))

          file_dir = self.cg._prepare_file_directory()

      def test_finalize_mmd_devel(self):

          self.cg.devel = True

                  }

              ],

              "arch": "noarch",

              "checksum_type": "md5",

              "type": "file",

              "extra": {

                      "version": "2",

                      "module_build_service_id": 2,

                      "content_koji_tag": "module-nginx-1.2",

                  }

              }

          },

                  }

              ],

              "arch": "noarch",

              "checksum_type": "md5",

              "type": "file",

              "extra": {

                      "version": "2",

                      "module_build_service_id": 2,

                      "content_koji_tag": "module-nginx-1.2",

                  }

              }

          },

  # Written by Ralph Bean <rbean@redhat.com>

  import os

  from tests.test_models import init_data, module_build_from_modulemd

  from tests import (init_data as init_data_contexts, clean_database)

              os.path.dirname(__file__), '..', 'staged_data', 'testmodule_dependencies.yaml')

          mmd = Modulemd.Module.new_from_file(yaml_path)

          mmd.upgrade()

          (build.ref_build_context, build.build_context, build.runtime_context,

           build.context) = ModuleBuild.contexts_from_mmd(build.modulemd)

          assert build.ref_build_context == 'f6e2aeec7576196241b9afa0b6b22acf2b6873d7'

          mmd.upgrade()

          with make_session(conf) as session:

              for i in range(3):

                  build.build_context = 'f6e2aeec7576196241b9afa0b6b22acf2b6873d' + str(i)

                  build.runtime_context = 'bbc84c7b817ab3dd54916c0bcd6c6bdf512f7f9c' + str(i)

                  session.add(build)

  from datetime import datetime

  from mock import patch, PropertyMock

  import pytest

  import module_build_service.resolver as mbs_resolver

  from module_build_service import app, db, models, glib, utils, Modulemd

              time_submitted=datetime(2018, 11, 15, 16, 8, 18),

              time_modified=datetime(2018, 11, 15, 16, 19, 35),

              rebuild_strategy='changed-and-after',

          )

          build.buildrequires.append(platform_f300103)

          db.session.add(build)

              xmd = glib.from_variant_dict(mmd.get_xmd())

              xmd['mbs']['buildrequires'] = {}

              mmd.set_xmd(glib.dict_values(xmd))

              db.session.add(module)

              db.session.commit()

          resolver = mbs_resolver.GenericResolver.create(tests.conf, backend='db')

              'version': '20180205135154'

          }

          mmd.set_xmd(glib.dict_values(xmd))

          module.name = 'testmodule2'

          module.version = str(mmd.get_version())

          module.koji_tag = 'module-ae2adf69caf0e1b6'

  from mock import patch, PropertyMock

  from gi.repository import GLib

  from tests import conf, clean_database

  from tests.test_views.test_views import FakeSCM

          testmodule_yml_path = os.path.join(

              self.staged_data_dir, 'testmodule_init.yaml')

          with open(testmodule_yml_path, 'r') as f:

          scmurl = 'git://pkgs.domain.local/modules/testmodule?#620ec77'

          clean_database()

          with make_session(conf) as session:

          filter_list.add("foo")

          filter_list.add("bar")

          mmd.set_rpm_filter(filter_list)

          db.session.commit()

          msg = module_build_service.messaging.MBSModule(

          includedmodules_yml_path = os.path.join(

              self.staged_data_dir, 'includedmodules.yaml')

          with open(includedmodules_yml_path, 'r') as f:

          scmurl = 'git://pkgs.domain.local/modules/includedmodule?#da95886'

          with make_session(conf) as session:

              ModuleBuild.create(

  # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE

  # SOFTWARE.