NAME=koji

  SPECFILE = $(firstword $(wildcard *.spec))

  ifndef PYTHON

  export PYTHON=python2

  endif

  ifdef DIST

  DIST_DEFINES := --define "dist $(DIST)"

  endif

  from urllib.parse import quote

  sys.path.insert(0, os.getcwd())

  import koji

  import kojixmlrpc

  import koji.xmlrpcplus

  %description utils

  Utilities for the Koji system

  %package web

  Summary: Koji Web UI

  Group: Applications/Internet

  popd

  %endif

  %if 0%{py2_support} > 1

      pushd $D

      make DESTDIR=$RPM_BUILD_ROOT PYTHON=%{__python2} install

      popd

  popd

  %endif

  %if 0%{py3_support} > 1

      pushd $D

      make DESTDIR=$RPM_BUILD_ROOT PYTHON=%{__python3} install

      popd

  %files -n python%{python3_pkgversion}-%{name}-hub

  %{_datadir}/koji-hub/*.py

  %{_datadir}/koji-hub/__pycache__

  %files hub-plugins

  %dir /etc/koji-hub/plugins

  PYVER_MAJOR := $(shell $(PYTHON) -c 'import sys; print(".".join(sys.version.split(".")[:1]))')

  PYFILES = $(wildcard *.py)

  PKGDIR = $(shell $(PYTHON) -c "from distutils.sysconfig import get_python_lib; print(get_python_lib())")/$(PACKAGE)

  SERVERDIR = /usr/share/koji-hub

  _default:

  	@echo "nothing to make.  try make install"

  		exit 1; \

  	fi

  	mkdir -p $(DESTDIR)/etc/httpd/conf.d

  	mkdir -p $(DESTDIR)/etc/koji-hub

  	mkdir -p $(DESTDIR)/etc/koji-hub/hub.conf.d

  # koji-hub is an xmlrpc interface to the Koji database

  #

  <Directory "/usr/share/koji-hub">

      Options ExecCGI

      :param str description: eg. "YAML Ain't Markup Language"

      :param str extensions: space-separated list of descriptions, eg. "yaml yml"

      """

      context.session.assertPerm('admin')

      verify_name_internal(name)

      convert_value(description, cast=str, check_only=True)

  import koji.plugin

  import koji.policy

  import koji.util

  from koji.context import context

  # import xmlrpclib functions from koji to use tweaked Marshaller

  from koji.server import ServerError, BadRequest, RequestTimeout

      log_handler.setFormatter(HubFormatter(opts['LogFormat']))

  def get_memory_usage():

      pagesize = resource.getpagesize()

      statm = [pagesize * int(y) // 1024

                  'Hub option DisableGSSAPIProxyDNFallback is deprecated and '

                  'will be removed in 1.29')

          setup_logging2(opts)

          koji.util.setup_rlimits(opts)

          plugins = load_plugins(opts)

          registry = get_registry(opts, plugins)

  import random

  import koji

  from koji.context import context

  from koji.plugin import export

  __all__ = ('runroot',)

  import koji

  from koji.context import context

  from koji.plugin import export

  __all__ = ('saveFailedTree',)

  # Copyright © 2019 Red Hat, Inc.

  #

  # SPDX-License-Identifier: GPL-2.0-or-later

  import koji

  from koji.db import QueryProcessor, nextval

  from koji.context import context

  from koji.plugin import callback, export

  import koji.policy

      _create_build_target,

      _create_tag,

      _delete_build_target,

  import mock

  import koji

  import kojihub

  IP = kojihub.InsertProcessor

  QP = kojihub.QueryProcessor

  class TestAddArchiveType(unittest.TestCase):

      def setUp(self):

          self.context.session.assertPerm = mock.MagicMock()

          self.exports = kojihub.RootExports()

          self.channel_name = 'test-channel'

          self.description = 'test-description'

                                            side_effect=self.getInsert).start()

          self.inserts = []

          self.insert_execute = mock.MagicMock()

                                           side_effect=self.getQuery).start()

          self.queries = []

          self.query_execute = mock.MagicMock()

          self.query_execute.side_effect = [[]]

          self.verify_name_internal.return_value = None

          self.get_archive_type.return_value = None

          self.assertEqual(len(self.inserts), 1)

          insert = self.inserts[0]

  class TestAddBType(unittest.TestCase):

      def test_add_btype(self, InsertProcessor, list_btypes, verify_name_internal):

          # Not sure why mock can't patch kojihub.context, so we do this

          mocks = [InsertProcessor, list_btypes, session]

          # It seems MagicMock will not automatically handle attributes that

          # start with "assert"

      def setUp(self):

          self.context.session.assertPerm = mock.MagicMock()

          self.exports = kojihub.RootExports()

          self.channel_name = 'test-channel'

          self.description = 'test-description'

                                            side_effect=self.getInsert).start()

          self.inserts = []

          self.insert_execute = mock.MagicMock()

      def tearDown(self):

          mock.patch.stopall()

      def setUp(self):

          self.tag_name = 'test-tag'

          self.parse_arches = mock.patch('koji.parse_arches').start()

          self.tag_info = {'id': 1, 'name': self.tag_name}

          self.external_repo_info = {'id': 123, 'name': 'test-repo'}

  class TestAddExternalRPM(unittest.TestCase):

      def setUp(self):

                                            side_effect=self.getInsert).start()

          self.inserts = []

          self.insert_execute = mock.MagicMock()

      def setUp(self):

          self.exports = kojihub.RootExports()

      def test_non_exist_user(self):

          data = [{'id': 3,

          return query

      def setUp(self):

                                            side_effect=self.getInsert).start()

          self.inserts = []

                                            side_effect=self.getUpdate).start()

          self.updates = []

                                           side_effect=self.getQuery).start()

          self.queries = []

          self.context_db = mock.patch('koji.db.context').start()

          # It seems MagicMock will not automatically handle attributes that

          # start with "assert"

          self.context.session.assertPerm = mock.MagicMock()

          self.context.opts = {'HostPrincipalFormat': '-%s-'}

          self.exports = kojihub.RootExports()

          self.query_singleValue = mock.MagicMock()

      def tearDown(self):

          self.assertEqual(r, 12)

          self.context.session.assertPerm.assert_called_once_with('host')

          self.context.session.createUser.assert_called_once_with(

              'hostname', usertype=koji.USERTYPES['HOST'], krb_principal='-hostname-')

          self.nextval.assert_called_once_with('host_id_seq')

              self.exports.addHost('hostname', ['i386', 'x86_64'], krb_principal=krb_principal)

          self.context.session.assertPerm.assert_called_once_with('host')

          self.context.session.createUser.assert_not_called()

          self.verify_host_name.assert_called_once_with('hostname')

          self.nextval.assert_not_called()

          return insert

      def setUp(self):

                                            side_effect=self.getInsert).start()

          self.inserts = []

          self.context_db = mock.patch('koji.db.context').start()

          # It seems MagicMock will not automatically handle attributes that

          # start with "assert"

          self.context_db.session.user_id = 23

          self.context.opts = {'HostPrincipalFormat': '-%s-'}

          self.exports = kojihub.RootExports()

          self.cname = 'channel_name'

          self.name = 'hostname'

          self.host_info = {'id': 123, 'name': self.name}

          return query

      def setUp(self):

                                            side_effect=self.getInsert).start()

          self.inserts = []

                                           side_effect=self.getQuery).start()

          self.queries = []

          self.query_execute = mock.MagicMock()

          # It seems MagicMock will not automatically handle attributes that

          # start with "assert"

          self.context.session.assertLogin = mock.MagicMock()

          mock.patch.stopall()

      @mock.patch('koji.plugin.run_callbacks')

      @mock.patch('os.path.isdir')

      @mock.patch('koji.ensuredir')

      def test_add_rpm_sig_header_signed(

              self,

              open,

  class TestAddUserKrbPrincipal(unittest.TestCase):

      def setUp(self):

          self.username = 'testuser'

          self.krbprincipal = '%s@TEST.COM' % self.username

          self.userinfo = {'id': 1, 'name': self.username}

  class TestAddVolume(unittest.TestCase):

      def setUp(self):

          # It seems MagicMock will not automatically handle attributes that

          # start with "assert"

          self.context.session.assertPerm = mock.MagicMock()

  import copy

  import unittest

  class TestApplyQueryOpts(unittest.TestCase):

      def test_basic(self):

          opts = None

          expected = copy.copy(self.original)

          self.assertEqual(expected, actual)

      def test_order_by_foo(self):

              {'foo': 1, 'bar': 1},

              {'foo': 2, 'bar': -1},

          ]

          self.assertEqual(expected, actual)

      def test_order_by_bar(self):

              {'foo': 0, 'bar': 0},

              {'foo': 1, 'bar': 1},

          ]

          self.assertEqual(expected, actual)

      def test_order_in_reverse(self):

              {'foo': 1, 'bar': 1},

              {'foo': 0, 'bar': 0},

          ]

          self.assertEqual(expected, actual)

      def test_offset(self):

              {'foo': 2, 'bar': -1},

              {'foo': 0, 'bar': 0},

          ]

          self.assertEqual(expected, actual)

      def test_limit(self):

              {'foo': 1, 'bar': 1},

              {'foo': 2, 'bar': -1},

          ]

          self.assertEqual(expected, actual)

      def test_limit_and_offset(self):

          expected = [

              {'foo': 2, 'bar': -1},

          ]

          self.assertEqual(expected, actual)

      def test_count_only(self):

          opts = {'countOnly': True}

          expected = 3

          self.assertEqual(expected, actual)

          opts = {'countOnly': True, 'offset': 2}

          expected = 1

          self.assertEqual(expected, actual)

  class TestBuild(unittest.TestCase):

      def setUp(self):

          self.exports = kojihub.RootExports()

          self.context.session.assertLogin = mock.MagicMock()

          self.context.session.hasPerm = mock.MagicMock()

          self.src = 'test-src'

          self.target = 'test-target'

  class TestBuildImage(unittest.TestCase):

      def setUp(self):

          self.exports = kojihub.RootExports()

          self.context.session.assertPerm = mock.MagicMock()

          self.context.session.hasPerm = mock.MagicMock()

          self.mock_parse_arches = mock.patch('koji.parse_arches').start()

          self.name = 'image-name'

          self.version = 'test-version'

  class TestBuildImageIndirection(unittest.TestCase):

      def setUp(self):

          self.exports = kojihub.RootExports()

          self.context.session.assertPerm = mock.MagicMock()

          self.context.session.hasPerm = mock.MagicMock()

  class TestBuildImageOz(unittest.TestCase):

      def setUp(self):

          self.exports = kojihub.RootExports()

          self.context.session.assertPerm = mock.MagicMock()

          self.context.session.hasPerm = mock.MagicMock()

              os.mkdir(self.TMP_PATH)

          self.path_work = mock.patch('koji.pathinfo.work').start()

          self.context_db = mock.patch('koji.db.context').start()

          self.userinfo = {'id': 123}

          self.rmtree = mock.patch('koji.util.rmtree').start()

          self.lexists = mock.patch('os.path.lexists').start()

          self.path_build = mock.patch('koji.pathinfo.build').start()

      def tearDown(self):

          if os.path.exists(self.TMP_PATH):

          x.get_metadata('default.json', 'cg_importer_json')

          x.import_metadata()

      def test_do_import_no_such_metadata(self, get_metadata):

          x = kojihub.CG_Importer()

          metadata = {'metadata_version': 99,

              'nvr': self.build1['nvr'],

              'filename': self.archive1['filename'],

          }

      def tearDown(self):

          mock.patch.stopall()

          return update

      def setUp(self):

                                            side_effect=self.getInsert).start()

                                            side_effect=self.getUpdate).start()

          self.inserts = []

          self.updates = []

          self.context_db.session.user_id = 123456

          self.mock_cursor = mock.MagicMock()

          self.context_db.cnx.cursor.return_value = self.mock_cursor

          self.userinfo = {'id': 123456, 'name': 'username'}

          self.run_callbacks = mock.patch('koji.plugin.run_callbacks').start()

      def tearDown(self):

  class TestChainBuild(unittest.TestCase):

      def setUp(self):

          self.exports = kojihub.RootExports()

          self.context.session.assertLogin = mock.MagicMock()

          self.context.session.hasPerm = mock.MagicMock()

          self.srcs = ['pkg1']

          self.target = 'test-target'

  class TestChainMaven(unittest.TestCase):

      def setUp(self):

          self.exports = kojihub.RootExports()

          self.context.session.assertLogin = mock.MagicMock()

          self.context.session.hasPerm = mock.MagicMock()

          self.builds = {'build1': {}, 'build2': {}, 'build3': {}}

          self.target = 'test-target'

  import koji

  import koji.policy

  import kojihub

  class OurException(Exception):

  class TestCheckVolumePolicy(unittest.TestCase):

      def setUp(self):