import ast

  import fnmatch

  import itertools

  import json

  import logging

  from six.moves import filter, map, range, zip

  import koji

  from koji_cli.lib import (

      _,

      _list_tasks,

          previous = session.queryRPMSigs(rpm_id=rinfo['id'], sigkey=sigkey)

          assert len(previous) <= 1

          if previous:

              if previous[0]['sighash'] == sighash:

                  print(_("Signature already imported: %s") % path)

                  continue

  import koji

  # import parse_arches to current namespace for backward compatibility

  from koji import parse_arches

  try:

      import krbV

      # check checksum/checksum_type

      if archive['checksum_type'] == koji.CHECKSUM_TYPES['md5']:

      elif archive['checksum_type'] == koji.CHECKSUM_TYPES['sha1']:

          hash = hashlib.sha1()

      elif archive['checksum_type'] == koji.CHECKSUM_TYPES['sha256']:

  import tempfile

  import time

  import traceback

  import zipfile

  import rpm

  import koji

  import koji.auth

      decode_bytes,

      dslice,

      joinpath,

      move_and_symlink,

      multi_fnmatch,

      safer_move,

                      (filesize, fileinfo['filename'], fileinfo['filesize']))

              # checksum

              with open(path, 'rb') as fp:

                  while True:

                      contents = fp.read(8192)

                      if not contents:

                          break

                      raise koji.GenericError("File checksum mismatch for %s: %s != %s" %

                                              (fileinfo['filename'], fileinfo['checksum'],

              if fileinfo['buildroot_id'] not in self.br_prep:

                  raise koji.GenericError("Missing buildroot metadata for id %(buildroot_id)r" %

          archiveinfo['filename'] = filename

          archiveinfo['size'] = fileinfo['filesize']

          archiveinfo['checksum'] = fileinfo['checksum']

              raise koji.GenericError("Unsupported checksum type: %(checksum_type)s" % fileinfo)

          archiveinfo['checksum_type'] = koji.CHECKSUM_TYPES[fileinfo['checksum_type']]

          archiveinfo['metadata_only'] = True

          archiveinfo['filename'] = filename

          archiveinfo['size'] = os.path.getsize(filepath)

          # trust values computed on hub (CG_Importer.prep_outputs)

              with open(filepath, 'rb') as archivefp:

                  while True:

                      contents = archivefp.read(8192)

                      if not contents:

                          break

          else:

              archiveinfo['checksum'] = fileinfo['checksum']

          if fileinfo:

              # check against metadata

              if archiveinfo['size'] != fileinfo['filesize']:

                  raise koji.GenericError("File size mismatch for %s: %s != %s" %

                                          (filename, archiveinfo['size'], fileinfo['filesize']))

                  raise koji.GenericError("File checksum mismatch for %s: %s != %s" %

                                          (filename, archiveinfo['checksum'], fileinfo['checksum']))

      archivetype = get_archive_type(filename, strict=True)

              continue

          if not os.path.isfile('%s/%s' % (mavendir, mavenfile)):

              continue

              sumfile = mavenfile + ext

              if sumfile not in mavenfiles:

                  sum = sum_constr()

          # we use the sigkey='' to represent unsigned in the db (so that uniqueness works)

      else:

          sigkey = koji.get_sigpacket_key_id(sigkey)

      rpm_id = rinfo['id']

      # - db entry

      q = """SELECT sighash FROM rpmsigs WHERE rpm_id=%(rpm_id)i AND sigkey=%(sigkey)s"""

          context.session.assertPerm('admin')

          return make_task(*args, **opts)

          """upload file to the hub

          chunk rather than the whole file.

          :param str path: the relative path to upload to

          :param str name: the name of the file

          :param int size: size of contents (bytes)

          :param str data: base64 encoded file contents

          :param int offset: The offset indicates where the chunk belongs.

                             The special offset -1 is used to indicate the final

                             chunk.

          :returns: True

          """

          # we will accept offset and size as strings to work around xmlrpc limits

          offset = koji.decode_int(offset)

          size = koji.decode_int(size)

              # this case is for backwards compatibility

              verify = "md5"

              verify = None

          else:

          sum_cls = get_verify_class(verify)

          if offset != -1:

              if size is not None:

              data['size'] = st.st_size

              data['mtime'] = st.st_mtime

              if verify:

                  if tail is not None:

                      if tail < 0:

                          raise koji.GenericError("invalid tail value: %r" % tail)

                      offset = max(st.st_size - tail, 0)

                      os.lseek(fd, offset, 0)

                  length = 0

                  chunk = os.read(fd, 8192)

                  while chunk:

                      length += len(chunk)

  def get_verify_class(verify):

      if verify == 'md5':

      elif verify == 'adler32':

          return koji.util.adler32_constructor

      elif verify:

          raise koji.GenericError("Unsupported verify type: %s" % verify)

      else:

              raise koji.GenericError("destination not a file: %s" % fn)

          if offset == 0 and not overwrite:

              raise koji.GenericError("upload path exists: %s" % fn)

      size = 0

      inf = environ['wsgi.input']

      fd = os.open(fn, os.O_RDWR | os.O_CREAT, 0o666)

      try:

          fo = open(localfile, "rb")  # specify bufsize?

          totalsize = os.path.getsize(localfile)

          ofs = 0

          debug = self.opts.get('debug', False)

          if callback:

              callback(0, totalsize, 0, 0, 0)

          while True:

              lap = time.time()

              contents = fo.read(blocksize)

              size = len(contents)

              data = util.base64encode(contents)

              if size == 0:

                  # end of file, use offset = -1 to finalize upload

                  offset = -1

                  sz = ofs

              else:

                  offset = ofs

                  sz = size

              del contents

              tries = 0

                  if debug:

                      self.logger.debug("uploadFile(%r,%r,%r,%r,%r,...)" %

                                        (path, name, sz, digest, offset))

                      break

                  if tries <= retries:

                      tries += 1

              break

          data = base64encode(contents)

          del contents

          tries = 0

          while True:

                  break

              if tries <= retries:

  from koji.xmlrpcplus import DateTime

  # imported from kojiweb and kojihub

  def deprecated(message):

      """Print deprecation warning"""

          f.seek(o)

          # compute md5 of rest of file

          while True:

              d = f.read(1024**2)

              if not d:

                  "build_id": 137,

                  "archive_id": "ARCHIVE_ID",

                  "type_id": "ARCHIVETYPE",

                  "filename": "tdl-x86_64.xml",

                  "btype_id": "BTYPEID:image",

                  "buildroot_id": null,

                  "id": 1001,

                  "build_id": 137,

                  "archive_id": "ARCHIVE_ID",

                  "type_id": "ARCHIVETYPE",

                  "filename": "image.ks",

                  "btype_id": "BTYPEID:image",

                  "buildroot_id": null,

                  "id": 1002,

                  "build_id": 137,

                  "archive_id": "ARCHIVE_ID",

                  "type_id": "ARCHIVETYPE",

                  "filename": "image-base.ks",

                  "btype_id": "BTYPEID:image",

                  "buildroot_id": null,

                  "id": 1003,

                  "build_id": 137,

                  "archive_id": "ARCHIVE_ID",

                  "type_id": "ARCHIVETYPE",

                  "filename": "foo-x86_64.xml",

                  "btype_id": "BTYPEID:image",

                  "buildroot_id": null,

                  "id": 1004,

                  "build_id": 137,

                  "archive_id": "ARCHIVE_ID",

                  "type_id": "ARCHIVETYPE",

                  "filename": "my-image-7.4.2-2.x86_64.ova",

                  "btype_id": "BTYPEID:image",

                  "buildroot_id": null,

                  "id": 1005,

      def test_get_verify_class_is_adler32(self):

          kojihub.get_verify_class('adler32') is adler32_constructor

  awk '/^# INSERT kojikamid dup #/ {exit} {print $0}' kojikamid.py

  do

      awk '/^# END kojikamid dup #/ {p=0} p {print $0} /^# BEGIN kojikamid dup #/ {p=1}' $fn

  done

              elif checksum_type == 'sha256':

                  checksum = hashlib.sha256()

              elif checksum_type == 'md5':

              else:

                  raise BuildError('Unknown checksum type %s for %s' % (  # noqa: F821

                                   checksum_type,

      destpath = os.path.join(prefix, path)

      fobj = open(destpath, 'r')

      offset = 0

      while True:

          data = fobj.read(131072)

          if not data:

          sum.update(data)

      fobj.close()

      digest = sum.hexdigest()

  def get_mgmt_server():

              if contents:

                  size = len(contents)

                  data = base64.b64encode(contents)

                  del contents

                  try:

                  except Exception:

                      log_local('error uploading %s' % relpath)

          time.sleep(1)

          fobj.close()

          return len(data)

          """

          Upload contents directly to the server.

          """

          remotepath = os.path.dirname(os.path.join(self.getUploadDir(), filepath))

          filename = os.path.basename(filepath)

          self.session.uploadFile(remotepath, filename, size,

      def verifyChecksum(self, path, checksum, algo='sha1'):

          local_path = os.path.abspath(os.path.join(self.output_dir, path))

          if algo == 'sha1':

              sum = hashlib.sha1()

          elif algo == 'md5':

          elif algo == 'sha256':

              sum == hashlib.sha256()

          else:

          raise koji.AuthError('Unable to authenticate, server secret not configured')

      digest_string = value + options['Secret'].value

      digest_string = digest_string.encode('utf-8')

      value = "%s:%s" % (shasum.hexdigest(), value)

      cookies = http.cookies.SimpleCookie()

      cookies['user'] = value

          raise koji.AuthError('Unable to authenticate, server secret not configured')

      digest_string = value + options['Secret'].value

      digest_string = digest_string.encode('utf-8')

      if shasum.hexdigest() != sig:

          authlogger.warning('invalid user cookie: %s:%s', sig, value)

          return None

          tstamp = _truncTime()

      value = user + str(tstamp) + environ['koji.options']['Secret'].value

      value = value.encode('utf-8')

  def _getValidTokens(environ):