)

  from koji.db import (

      BulkInsertProcessor,

      InsertProcessor,

      QueryProcessor,

      Savepoint,

                             values=volinfo, columns=['id'], opts={'limit': 1})

      if query.execute():

          raise koji.GenericError('volume %(name)s has build references' % volinfo)

  def list_volumes():

                                old=old['state'], new=data['state'], info=data)

      # If there is any old build type info, clear it

      data['id'] = old['id']

      update = UpdateProcessor('build', clauses=['id=%(id)s'], values=data)

  def clear_reservation(build_id):

      '''Remove reservation entry for build'''

  def cg_init_build(cg, data):

      clauses = ["rpm_id=%(rpm_id)i"]

      if sigkey is not None:

          clauses.append("sigkey=%(sigkey)s")

      rpm_id = rinfo['id']

      binfo = get_build(rinfo['build_id'])

      builddir = koji.pathinfo.build(binfo)

      list_sigcaches = []

      query = QueryProcessor(tables=['rpminfo'], columns=['id'], clauses=['build_id=%(build_id)i'],

                             values={'build_id': build_id}, opts={'asList': True})

      for (rpm_id,) in query.execute():

      values = {'build_id': build_id}

      update = UpdateProcessor('tag_listing', clauses=["build_id=%(build_id)i"], values=values)

      update.make_revoke()

      query = QueryProcessor(tables=['rpminfo'], columns=['id'], clauses=['build_id=%(id)i'],

                             values=binfo, opts={'asList': True})

      for (rpm_id,) in query.execute():

      query = QueryProcessor(tables=['archiveinfo'], columns=['id'], clauses=['build_id=%(id)i'],

                             values=binfo, opts={'asList': True})

      for (archive_id,) in query.execute():

      binfo['state'] = koji.BUILD_STATES['CANCELED']

      update = UpdateProcessor('build', clauses=['id=%(id)s'], values=binfo,

                               data={'state': binfo['state'], 'task_id': None, 'volume_id': 0})

              Task(task_id).cancelFull(strict=False)

      # remove possible CG reservations

      build = get_build(build_id, strict=True)

      koji.plugin.run_callbacks('postBuildStateChange',

                  self.hasPerm('admin')):

              raise koji.GenericError('user %i cannot delete notifications for user %i' %

                                      (currentUser['id'], notification['user_id']))

      def createNotificationBlock(self, user_id, package_id=None, tag_id=None):

          """Create notification block. If the user_id does not match the

                  self.hasPerm('admin')):

              raise koji.GenericError('user %i cannot delete notification blocks for user %i' %

                                      (currentUser['id'], block['user_id']))

      def _prepareSearchTerms(self, terms, matchType):

          r"""Process the search terms before passing them to the database.

  from .context import context

  from .util import to_list

  # 1 - load session if provided

                  'cannot remove Kerberos Principal:'

                  ' %(krb_principal)s with user %(name)s' % locals())

          cursor = context.cnx.cursor()

          context.cnx.commit()

          return user_id

          return _dml(str(self), self.get_values())

  class QueryProcessor(object):

      """

      Build a query from its components.

  from koji.context import context

  from koji.plugin import callback, convert_datetime, ignore_error

  from kojihub import get_build_type

  CONFIG_FILE = '/etc/koji-hub/plugins/protonmsg.conf'

  CONFIG = None

          if not max_age:

              # age in config file is deprecated

              max_age = CONFIG.getint('queue', 'age', fallback=24)

          query = QueryProcessor(tables=('proton_queue',),

                                 columns=('id', 'address', 'props', 'body::TEXT'),

                                 aliases=('id', 'address', 'props', 'body'),

              unsent = {m['id'] for m in _send_msgs(urls, list(msgs), CONFIG)}

          sent = [m for m in msgs if m['id'] not in unsent]

          if sent:

      finally:

          # make sure we free the lock

          try:

  import koji

  import kojihub

  class TestDeleteNotifications(unittest.TestCase):

      def setUp(self):

          self.context = mock.patch('kojihub.context').start()

              'EmailDomain': 'test.domain.com',

              'NotifyOnSuccess': True,

          }

          self.exports = kojihub.RootExports()

          self.exports.getLoggedInUser = mock.MagicMock()

          self.exports.getBuildNotification.return_value = {'user_id': self.user_id}

          self.exports.deleteNotification(self.n_id)

          self.exports.getBuildNotification.assert_called_once_with(self.n_id, strict=True)

          self.exports.getLoggedInUser.assert_called_once_with()

      def test_deleteNotification_missing(self):

          self.exports.getBuildNotification.side_effect = koji.GenericError

          with self.assertRaises(koji.GenericError):

              self.exports.deleteNotification(self.n_id)

          self.exports.getBuildNotification.assert_called_once_with(self.n_id, strict=True)

          with self.assertRaises(koji.GenericError) as cm:

              self.exports.deleteNotification(self.n_id)

          self.assertEqual('Not logged-in', str(cm.exception))

          self.exports.getBuildNotification.assert_called_once_with(self.n_id, strict=True)

      def test_deleteNotification_no_perm(self):

          self.exports.getBuildNotification.return_value = {'user_id': self.user_id}

              self.exports.deleteNotification(self.n_id)

          self.assertEqual(f'user 1 cannot delete notifications for user {self.user_id}',

                           str(cm.exception))

          self.exports.getBuildNotification.assert_called_once_with(self.n_id, strict=True)

  import koji

  import kojihub

  class TestDeleteNotificationsBlocks(unittest.TestCase):

      def setUp(self):

          self.context = mock.patch('kojihub.context').start()

              'NotifyOnSuccess': True,

          }

          self.get_user = mock.patch('kojihub.get_user').start()

          self.exports = kojihub.RootExports()

          self.exports.getLoggedInUser = mock.MagicMock()

          self.exports.getBuildNotificationBlock.return_value = {'user_id': self.user_id}

          self.exports.deleteNotificationBlock(self.n_id)

          self.exports.getBuildNotificationBlock.assert_called_once_with(self.n_id, strict=True)

          self.exports.getLoggedInUser.assert_called_once_with()

      def test_deleteNotificationBlock_missing(self):

          self.exports.getBuildNotificationBlock.side_effect = koji.GenericError

          with self.assertRaises(koji.GenericError):

              self.exports.deleteNotificationBlock(self.n_id)

          self.exports.getBuildNotificationBlock.assert_called_once_with(self.n_id, strict=True)

          with self.assertRaises(koji.GenericError) as cm:

              self.exports.deleteNotificationBlock(self.n_id)

          self.assertEqual('Not logged-in', str(cm.exception))

          self.exports.getBuildNotificationBlock.assert_called_once_with(self.n_id, strict=True)

      def test_deleteNotificationBlock_no_perm2(self):

          self.exports.getBuildNotificationBlock.return_value = {'user_id': self.user_id}

              self.exports.deleteNotificationBlock(self.n_id)

          self.assertEqual(f'user 1 cannot delete notification blocks for user {self.user_id}',

                           str(cm.exception))

          self.exports.getBuildNotificationBlock.assert_called_once_with(self.n_id, strict=True)

  import koji

  import kojihub

  class TestDeleteRPMSig(unittest.TestCase):

      def setUp(self):

          self.get_rpm = mock.patch('kojihub.get_rpm').start()

          self.query_rpm_sigs = mock.patch('kojihub.query_rpm_sigs').start()

          self.get_build = mock.patch('kojihub.get_build').start()

      def tearDown(self):

          mock.patch.stopall()

          rpm_id = 1234

          expected_msg = 'No such rpm: %s' % rpm_id

          self.get_rpm.side_effect = koji.GenericError("No such rpm: %s" % rpm_id)

          with self.assertRaises(koji.GenericError) as ex:

              kojihub.delete_rpm_sig(rpm_id, all_sigs=True)

          self.assertEqual(ex.exception.args[0], expected_msg)

          self.get_rpm.assert_called_once_with(rpm_id, strict=True)

          self.query_rpm_sigs.assert_not_called()

          expected_msg = 'No signature specified'

          with self.assertRaises(koji.GenericError) as ex:

              kojihub.delete_rpm_sig(1234)

          self.assertEqual(ex.exception.args[0], expected_msg)

          self.get_rpm.assert_not_called()

          self.query_rpm_sigs.assert_not_called()

          rpminfo = 1234

          rinfo = {'external_repo_id': 1, 'external_repo_name': 'INTERNAL'}

          self.get_rpm.return_value = rinfo

          with self.assertRaises(koji.GenericError) as ex:

              kojihub.delete_rpm_sig(rpminfo, all_sigs=True)

          expected_msg = "Not an internal rpm: %s (from %s)" % (rpminfo, rinfo['external_repo_name'])

          self.assertEqual(ex.exception.args[0], expected_msg)

          self.get_rpm.assert_called_once_with(rpminfo, strict=True)

          self.query_rpm_sigs.assert_not_called()

          rpminfo = 1234

          nvra = "%s-%s-%s.%s" % (self.rinfo['name'], self.rinfo['version'], self.rinfo['release'],

                                  self.rinfo['arch'])

          self.query_rpm_sigs.return_value = []

          with self.assertRaises(koji.GenericError) as ex:

              kojihub.delete_rpm_sig(rpminfo, all_sigs=True)

          self.assertEqual(ex.exception.args[0], expected_msg)

          self.get_rpm.assert_called_once_with(rpminfo, strict=True)

          self.query_rpm_sigs.assert_called_once_with(rpm_id=self.rinfo['id'], sigkey=None)

      @mock.patch('koji.pathinfo.build', return_value='fakebuildpath')

      @mock.patch('os.remove')

          rpminfo = 2

          os_remove.side_effect = FileNotFoundError()

          self.get_rpm.return_value = self.rinfo

          self.get_build.return_value = self.buildinfo

          self.get_user.return_value = self.userinfo

          self.query_rpm_sigs.return_value = self.queryrpmsigs

          self.assertEqual(r, None)

          self.get_rpm.assert_called_once_with(rpminfo, strict=True)

          self.get_build.assert_called_once_with(self.rinfo['build_id'])

      @mock.patch('koji.pathinfo.build', return_value='fakebuildpath')

      @mock.patch('os.remove', side_effect=OSError)

          rpminfo = 2

          filepath = 'fakebuildpath/data/signed/x86_64/fs_mark-3.3-20.el8.x86_64.rpm'

          self.get_rpm.return_value = self.rinfo

          with self.assertRaises(koji.GenericError) as ex:

              kojihub.delete_rpm_sig(rpminfo, all_sigs=True)

          self.assertEqual(ex.exception.args[0], expected_msg)

          self.get_rpm.assert_called_once_with(rpminfo, strict=True)

          self.query_rpm_sigs.assert_called_once_with(rpm_id=self.rinfo['id'], sigkey=None)

          self.get_build.assert_called_once_with(self.rinfo['build_id'])

      @mock.patch('koji.pathinfo.build', return_value='fakebuildpath')

      @mock.patch('os.remove')

          rpminfo = 2

          self.get_rpm.return_value = self.rinfo

          self.get_build.return_value = self.buildinfo

          self.get_user.return_value = self.userinfo

          self.query_rpm_sigs.return_value = self.queryrpmsigs

          kojihub.delete_rpm_sig(rpminfo, all_sigs=True)

          self.get_rpm.assert_called_once_with(rpminfo, strict=True)

          self.query_rpm_sigs.assert_called_once_with(rpm_id=self.rinfo['id'], sigkey=None)

          self.get_build.assert_called_once_with(self.rinfo['build_id'])

  import koji

  import koji.db

  def clean_sessions(cursor, vacuum, test, age, absolute):

          print(f"Deleting {rows} sessions")

      if not test:

          if vacuum:

              cursor.execute("VACUUM ANALYZE sessions")

  def clean_reservations(cursor, vacuum, test, age):

      if options.verbose:

          rows = query.execute()

          print(f"Deleting {rows} build reservations")

      if not test:

          if vacuum:

              cursor.execute("VACUUM ANALYZE build_reservations")

          print(f"Deleting {rows} tagNotification tasks")

      if not test:

          if vacuum:

              cursor.execute("VACUUM ANALYZE task")

          return

      # delete standard buildroots

      # delete tasks finally

      if vacuum:

          cursor.execute("VACUUM ANALYZE standard_buildroot")

      if not test:

          q = "FROM buildroot WHERE cg_id IS NULL AND id NOT IN " \

              "(SELECT buildroot_id FROM standard_buildroot)"

          if vacuum:

              cursor.execute("VACUUM ANALYZE buildroot_listing")

              cursor.execute("VACUUM ANALYZE buildroot")