rm -f /var/lib/copr-rpmbuild/pid

  rm -f /var/lib/copr-rpmbuild/main.log

  rm -rf /var/lib/copr-rpmbuild/results

  shopt -s nullglob

  set -- /etc/copr-builder/hooks/cleanup/*.sh

  install -d %{buildroot}%mock_config_overrides

  install -d %{buildroot}%{_sharedstatedir}/copr-rpmbuild

  install -d %{buildroot}%{_sharedstatedir}/copr-rpmbuild/results

  install -d %{buildroot}%{_bindir}

  install -m 755 main.py %{buildroot}%{_bindir}/copr-rpmbuild

  %dir %attr(0775, root, mock) %{_sharedstatedir}/copr-rpmbuild

  %dir %attr(0775, root, mock) %{_sharedstatedir}/copr-rpmbuild/results

  %dir %{_sysconfdir}/copr-rpmbuild

  %config(noreplace) %{_sysconfdir}/copr-rpmbuild/main.ini

  def read_config(config_path=None):

      config = configparser.RawConfigParser(defaults={

          "resultdir": "/var/lib/copr-rpmbuild/results",

          "lockfile": "/var/lib/copr-rpmbuild/lockfile",

          "logfile": "/var/lib/copr-rpmbuild/main.log",

          "pidfile": "/var/lib/copr-rpmbuild/pid",

  import os

  import errno

  import logging

  import tempfile

  from ..helpers import string2list

  class Provider(object):

          self.config = config

          try:

              os.mkdir(self.workdir)

          except OSError as e:

          # Change home directory to workdir and create .rpmmacros there

          os.environ["HOME"] = self.workdir

          self.create_rpmmacros()

      def create_rpmmacros(self):

          path = os.path.join(self.workdir, ".rpmmacros")

      workdir = None

          self.chroot = source_json.get('chroot')

          self.inner_resultdir = source_json.get('resultdir')

          self.builddeps = source_json.get('builddeps')

          if 'hook_data' in source_json:

              self.hook_payload_url = "{server}/tmp/{tmp}/hook_payload".format(

                  tmp=source_json['tmp'],

              )

          self.file_script = os.path.join(self.workdir, 'script')

          with open(self.file_script, 'w') as script:

              script.write(source_json['script'])

      def produce_srpm(self):

          with open(mock_config_file, 'w') as f:

              # Enable network.

          if self.hook_payload_url:

              chunk_size = 1024

              response = requests.get(self.hook_payload_url, stream=True)

              response.raise_for_status()

          helpers.run_cmd(mock + ['--copyout', inner_resultdir, srpm_srcdir])

          helpers.run_cmd(mock + ['--scrub', 'all'])

          shutil.rmtree(srpm_srcdir)

  """

  import os

  from copr_rpmbuild import helpers

  class DistGitProvider(Provider):

      """

      DistGit provider, wrapper around copr-distgit-client script

      """

          self.clone_to = os.path.join(

              self.workdir,

              helpers.git_clone_url_basepath(self.clone_url))

      def produce_srpm(self):

          self.produce_sources()

          helpers.run_cmd([

          ], cwd=self.clone_to)

  class PyPIProvider(Provider):

          self.pypi_package_version = source_json["pypi_package_version"]

          self.pypi_package_name = source_json["pypi_package_name"]

          self.spec_template = source_json.get("spec_template", '')

          self.tool_presence_check()

          cmd = ["pyp2rpm", self.pypi_package_name, "-t", self.spec_template,

          for i, python_version in enumerate(self.python_versions):

              if i == 0:

  class RubyGemsProvider(Provider):

      def tool_presence_check(self):

          try:

      def produce_srpm(self):

          self.tool_presence_check()

          result = run_cmd(cmd)

          if "Empty tag: License" in result.stderr:

  class ScmProvider(Provider):

          self.scm_type = source_dict.get('type') or 'git'

          self.clone_url = source_dict.get('clone_url')

          self.committish = source_dict.get('committish')

          self.spec_path = helpers.path_join(

              self.repo_path, os.path.join(self.repo_subdir, self.spec_relpath))

      def generate_rpkg_config(self):

          parsed_clone_url = urlparse(self.clone_url)

          distgit_config_section = None

      def get_rpkg_command(self):

          self.generate_rpkg_config()

      def get_tito_command(self):

      def get_tito_test_command(self):

      def get_make_srpm_command(self):

          mock_repodir = helpers.path_join(mock_workdir, self.repo_dirname)

          mock_cwd = helpers.path_join(mock_repodir, self.repo_subdir)

          mock_spec_path = helpers.path_join(

          mock_bind_mount_cmd_part = \

              '--plugin-option=bind_mount:dirs=(("{0}", "{1}"), ("{2}", "{3}"))'\

          makefile_path = os.path.join(mock_repodir, '.copr', 'Makefile')

          make_srpm_cmd_part = \

              'cd {0}; make -f {1} srpm outdir="{2}" spec="{3}"'\

          return ['mock', '--uniqueext', get_mock_uniqueext(),

                  '-r', '/etc/copr-rpmbuild/mock-source-build.cfg',

  class UrlProvider(Provider):

          self.parsed_url = urlparse(self.url)

      def save_spec(self):

          cmd = ["mock", "-r", "/etc/copr-rpmbuild/mock-source-build.cfg",

                 "--buildsrpm", "--spec", spec_path,

                 "--define", "_disable_source_fetch 0",

          return run_cmd(cmd, cwd=self.workdir)

      def download_srpm(self):

          basename = os.path.basename(self.parsed_url.path)

          response = requests.get(self.url, stream=True)

          if response.status_code != 200:

              raise RuntimeError('Requests get status "{0}" for "{1}"'.format(

  [main]

  frontend_url = https://copr.fedoraproject.org

  backend_url = https://copr-be.cloud.fedoraproject.org

  enabled_source_protocols = https ftps

  distgit_lookaside_url = {scheme}://{netloc}/repo/pkgs/%(ns1)s/%(name)s/%(filename)s/%(hashtype)s/%(hash)s/%(filename)s

  distgit_clone_url = {scheme}://{netloc}/%(module)s

  # The final %vendor would be e.g. "Fedora Copr - group @copr"

  #rpm_vendor_copr_name = Fedora Copr

  [distgit0]

  distgit_hostname_pattern = src.fedoraproject.org

  distgit_lookaside_url = https://src.fedoraproject.org/repo/pkgs/%(ns1)s/%(name)s/%(filename)s/%(hashtype)s/%(hash)s/%(filename)s

  import argparse

  import json

  import logging

  import shutil

  import pprint

  import pipes

  import pkg_resources

          os.makedirs(resultdir)

      """

      """

      try:

          provider = providers.factory(task["source_type"])(

          provider.produce_srpm()

      finally:

  def get_task(args, config, build_config_url_path=None, task_id=None):

      task = get_task(args, config, build_config_url_path)

      log_task(task)

      log.info("Output: {0}".format(

          os.listdir(resultdir)))

      task = get_task(args, config, build_config_url_path, task_id)

      log_task(task)

      try:

          distgit = providers.DistGitProvider(

              {"clone_url": task["git_repo"], "committish": task["git_hash"]},

          )

          distgit.produce_sources()

          resultdir = config.get("main", "resultdir")

          builder = MockBuilder(task, distgit.clone_to, resultdir, config)

          run_automation_tools(task, resultdir, builder.mock_config_file, log)

      finally:

          builder.archive_configs()

  def dump_configs(args, config):

  import os

  import tempfile

  import unittest

  from copr_rpmbuild import helpers

  """

  class TestCase(unittest.TestCase):

      def setUp(self):

          self.config_path, self.config = self.read_config_data(CONFIG)

      def tearDown(self):

          os.unlink(self.config_path)

      def read_config_data(self, config_data):

          fd, config_path = tempfile.mkstemp()

  from copr_rpmbuild.providers.base import Provider

  from . import TestCase

      def setUp(self):

          super(TestProvider, self).setUp()

          self.source_json = {}

      @mock.patch('{0}.open'.format(builtins), new_callable=mock.mock_open())

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      def test_create_rpmmacros(self, mock_mkdir, mock_open):

          rpmmacros = mock.MagicMock()

          mock_open.return_value = rpmmacros

          provider.create_rpmmacros()

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      @mock.patch('copr_rpmbuild.providers.base.Provider.create_rpmmacros')

          self.workdir = tempfile.mkdtemp(prefix="copr-distgit-provider-test-")

          self.origin = os.path.join(self.workdir, "origin.git")

          os.mkdir(self.origin)

          os.chdir(self.origin)

          self.lookaside = os.path.join(self.workdir, "lookaside")

          os.mkdir(self.lookaside)

          ])

          self._setup_configdir()

      def teardown_method(self, method):

          _unused_but_needed_for_el6 = (method)

          self.env_patch.stop()

      def test_distgit_method(self):

          source_dict = {"clone_url": self.origin}

          dgp.produce_srpm()

  @pytest.mark.parametrize('committish', ["main", None, ""])

  import os

  import pytest

  from copr_common.enums import BuildSourceEnum

  from main import produce_srpm

  try:

       from unittest import mock

  except ImportError:

       # Python 2 version depends on mock

       import mock

      config = {}

      task = {"source_type": BuildSourceEnum.upload,

              "source_json": {"url": "http://foo.ex/somepackage.spec"}}

      @mock.patch("copr_rpmbuild.providers.spec.UrlProvider.produce_srpm")

          # Test that we cleanup after successful build

          mock_produce_srpm.side_effect = RuntimeError("Jeeez, something failed")

          with pytest.raises(RuntimeError):

      @mock.patch("{0}.open".format(builtins))

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      def test_init(self, mock_mkdir, mock_open):

         self.assertEqual(provider.pypi_package_version, "1.52")

         self.assertEqual(provider.pypi_package_name, "motionpaint")

         self.assertEqual(provider.spec_template, "epel7")

      @mock.patch("{0}.open".format(builtins))

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      def test_produce_srpm(self, mock_mkdir, mock_open, run_cmd):

          provider.produce_srpm()

          run_cmd.assert_called_with(assert_cmd)

      def setUp(self):

          super(TestRubyGemsProvider, self).setUp()

          self.source_json = {"gem_name": "A_123"}

      @mock.patch("{0}.open".format(builtins))

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      def test_init(self, mock_mkdir, mock_open):

          self.assertEqual(provider.gem_name, "A_123")

      @mock.patch("copr_rpmbuild.providers.rubygems.run_cmd")

      @mock.patch("{0}.open".format(builtins))

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      def test_produce_srpm(self, mock_mkdir, mock_open, run_cmd):

          provider.produce_srpm()

          run_cmd.assert_called_with(assert_cmd)

      @mock.patch("copr_rpmbuild.providers.rubygems.run_cmd")

                    "Command failed: rpmbuild -bs --nodeps --define '_sourcedir /tmp/gem2rpm-foo-20170905-3367-c2flks'"

                    "--define '_srcrpmdir .' /tmp/gem2rpm-foo-20170905-3367-c2flks/rubygem-foo.spec")

          run_cmd.return_value = Munch({"stderr": stderr})

          with pytest.raises(RuntimeError) as ex:

              provider.produce_srpm()

              assert "Not specifying a license means all rights are reserved" in str(ex.exception)

  import tempfile

  import os

  import configparser

  import shutil

              "spec": "pkg.spec",

              "srpm_build_method": "rpkg",

          }

      @mock.patch('{0}.open'.format(builtins), new_callable=mock.mock_open())

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      def test_init(self, mock_mkdir, mock_open):

          source_json = self.source_json.copy()

          self.assertEqual(provider.scm_type, "git")

          self.assertEqual(provider.clone_url, "https://example.org/somerepo.git")

          self.assertEqual(provider.committish, "f28")

          source_json["subdirectory"] = "/SOURCES"

          source_json["spec"] = "/SPECS/pkg.spec"

          self.assertEqual(provider.repo_subdir, "/SOURCES")

          self.assertEqual(provider.spec_relpath, "/SPECS/pkg.spec")

          self.assertEqual(provider.repo_path, os.path.join(provider.workdir, "somerepo"))

      def test_generate_rpkg_config(self):

          tmpdir = tempfile.mkdtemp(prefix="copr-rpmbuild-test-")

          rpkg_tmpdir = tempfile.mkdtemp(prefix="copr-rpmbuild-test-", dir=tmpdir)

          rpkg_config = open(os.path.join(rpkg_tmpdir, "rpkg.conf.j2"), "w")

          rpkg_config.write(RPKG_CONF_JINJA)

          source_json["clone_url"] = "http://copr-dist-git.fedorainfracloud.org/git/clime/project/pkg.git"

          with mock.patch("copr_rpmbuild.providers.scm.CONF_DIRS", new=[rpkg_tmpdir]):

              rpkg_config_path = provider.generate_rpkg_config()

          config = configparser.RawConfigParser()

          source_json["clone_url"] = "http://unknownurl/git/clime/project/pkg.git"

          with mock.patch("copr_rpmbuild.providers.scm.CONF_DIRS", new=[rpkg_tmpdir]):

              rpkg_config_path = provider.generate_rpkg_config()

              self.assertEqual(rpkg_config_path, os.path.join(os.environ['HOME'], '.config', 'rpkg.conf'))

      @mock.patch('{0}.open'.format(builtins), new_callable=mock.mock_open())

      @mock.patch('copr_rpmbuild.providers.base.os.mkdir')

      def test_get_rpkg_command(self, mock_mkdir, mock_open):