from koji.util import base64encode

  from koji.util import decode_bytes

  from koji.util import dslice

  from koji.util import move_and_symlink

  from koji.util import multi_fnmatch

  from koji.util import safer_move

      #generate pkglist files

      pkglist = {}

      for repoarch in repo_arches:

          koji.ensuredir(archdir)

          # Make a symlink to our topdir

          top_relpath = os.path.relpath(koji.pathinfo.topdir, archdir)

          os.symlink(top_relpath, top_link)

      #NOTE - rpms is now an iterator

      for rpminfo in rpms:

          if not with_debuginfo and koji.is_debuginfo(rpminfo['name']):

      #write blocked package lists

      for repoarch in repo_arches:

          for pkg in blocks:

              blocklist.write(pkg['package_name'])

              blocklist.write('\n')

                           'epoch': archive['build_epoch'],

                           'volume_name': archive['volume_name'],

                          }

              dir_links.add((srcdir, destlink))

              dest_parent = os.path.dirname(destlink)

              artifact_dirs.setdefault(dest_parent, set()).add((archive['group_id'],

    </versioning>

  </metadata>

  """ % datetime.datetime.now().strftime('%Y%m%d%H%M%S')

          mdfile.write(contents)

      _generate_maven_metadata(destdir)

      insert.execute()

      repodir = koji.pathinfo.distrepo(repo_id, tinfo['name'], volume=volume)

      for arch in arches:

      if volume and volume != 'DEFAULT':

          # symlink from main volume to this one

          basedir = koji.pathinfo.distrepo(repo_id, tinfo['name'])

          os.symlink(relpath, basedir)

      # handle comps

      if task_opts.get('comps'):

          koji.ensuredir(groupsdir)

              task_opts['comps']), groupsdir + '/comps.xml')

      # write repo info to disk

      repo_info = {

      for dirpath, dirs, files in os.walk(logdir):

          subdir = os.path.relpath(dirpath, logdir)

          for fn in files:

              if os.path.islink(filepath):

                  logger.warning("Symlink under logdir: %s", filepath)

                  continue

      if btype == 'maven':

          maven_archive = get_maven_archive(archive_info['id'], strict=True)

          archive_info.update(maven_archive)

      elif btype == 'win':

          win_archive = get_win_archive(archive_info['id'], strict=True)

          archive_info.update(win_archive)

      elif btype == 'image':

          image_archive = get_image_archive(archive_info['id'], strict=True)

          archive_info.update(image_archive)

      elif btype:

          # for non-legacy types, btype info is in the 'extra' field

      else:

          # should not happen

          raise koji.GenericError("Missing build type info for archive %s" % archive_id)

          for path, dirs, files in os.walk(taskDir):

              for filename in files:

                  relpath = path[len(taskDir) + 1:]

                  if stat:

                      stat_map = {}

                      for attr in dir(stat_info):

                          if attr == 'st_size':

      for arch in logs:

          for log in logs[arch]:

              if os.path.basename(log) == 'noarch_rpmdiff.json':

                  for task_id in task_hash:

                      hashes[task_id] = task_hash[task_id]

          if metadata.endswith('.json'):

              # handle uploaded metadata

              workdir = koji.pathinfo.work()

              if not os.path.exists(path):

                  raise koji.GenericError("No such file: %s" % metadata)

              with open(path, 'rt') as fo:

          #       - doesn't fit with current major archive categories

          builddir = koji.pathinfo.build(self.buildinfo)

          koji.ensuredir(builddir)

          with open(path, 'w') as fo:

              fo.write(self.raw_metadata)

              if fileinfo.get('metadata_only', False):

                  self.metadata_only = True

              workdir = koji.pathinfo.work()

              fileinfo['hub.path'] = path

              filesize = os.path.getsize(path)

      rpm_task_dir = koji.pathinfo.task(task_id)

      for rpm_path in [rpm_results['srpm']] + rpm_results['rpms']:

          rpm_info = import_rpm(rpm_path, build_info, rpm_buildroot_id, wrapper=True)

          import_rpm_file(rpm_path, build_info, rpm_info)

          add_rpm_sig(rpm_info['id'], koji.rip_rpm_sighdr(rpm_path))

      for log in rpm_results['logs']:

          # assume we're only importing noarch packages

                           build_info, subdir='noarch')

  def merge_scratch(task_id):

      for task_id, info in tasks.items():

          taskpath = koji.pathinfo.task(task_id)

          for filename in info['rpms']:

              rpminfo = import_rpm(filepath, build, info['buildroot_id'])

              import_rpm_file(filepath, build, rpminfo)

              add_rpm_sig(rpminfo['id'], koji.rip_rpm_sighdr(filepath))

          for logname in info['logs']:

              import_build_log(logpath, build, subdir=info['arch'])

      # flag tags whose content has changed, so relevant repos can be regen'ed

          if not metadata_only:

              # move the file to it's final destination

              _import_archive_file(filepath, mavendir)

              _generate_maven_metadata(mavendir)

      elif type == 'win':

          if not metadata_only:

              destdir = koji.pathinfo.winbuild(buildinfo)

              if relpath:

              _import_archive_file(filepath, destdir)

      elif type == 'image':

          insert = InsertProcessor('image_archives')

          insert.set(arch=typeInfo['arch'])

          insert.execute()

          if not metadata_only:

              _import_archive_file(filepath, imgdir)

          # import log files?

      else:

          # ignore differences in file size, md5sum, and mtime

          # (files may have been generated at build time and contain

          #  embedded dates or other insignificant differences)

          if d.differs():

              raise koji.BuildError(

                  'The following noarch package built differently on different architectures: %s\n'

      imgdata['relpath'] = koji.pathinfo.taskrelpath(imgdata['task_id'])

      archives = []

      for imgfile in imgdata['files']:

          archivetype = get_archive_type(imgfile)

          logger.debug('image type we are importing is: %s' % archivetype)

          if not archivetype:

      # upload logs

      logs = [f for f in os.listdir(workpath) if f.endswith('.log')]

      for logfile in logs:

          if tinfo['method'] == 'livemedia':

              # multiarch livemedia spins can have log name conflicts, so we

              # add the arch to the path

          else:

          koji.ensuredir(logdir)

          if os.path.exists(final_path):

              raise koji.GenericError("Error importing build log. %s already exists." % final_path)

          if os.path.islink(logsrc) or not os.path.isfile(logsrc):

              if not srpms:

                  return _applyQueryOpts([], queryOpts)

              srpm_info = srpms[0]

          elif taskID:

              if not filepath:

                  raise koji.GenericError('filepath must be spcified with taskID')

              if filepath.startswith('/') or '../' in filepath:

                  raise koji.GenericError('invalid filepath: %s' % filepath)

          else:

              raise koji.GenericError('either buildID or taskID and filepath must be specified')

                                          " because RPM: %s is not internal" % rpmID)

              return _applyQueryOpts([], queryOpts)

          build_info = get_build(rpm_info['build_id'])

          if not os.path.exists(rpm_path):

              if strict:

                  raise koji.GenericError("RPM file of %s doesn't exist" % rpmID)

          if not rpm_info or not rpm_info['build_id']:

              return _applyQueryOpts([], queryOpts)

          build_info = get_build(rpm_info['build_id'])

          if not os.path.exists(rpm_path):

              return _applyQueryOpts([], queryOpts)

          if not rpm_info or not rpm_info['build_id']:

              return {}

          build_info = get_build(rpm_info['build_id'])

          if not os.path.exists(rpm_path):

              return {}

              if not rpm_info or not rpm_info['build_id']:

                  return {}

              build_info = get_build(rpm_info['build_id'])

              if not os.path.exists(rpm_path):

                  return {}

          elif taskID:

                  raise koji.GenericError('filepath must be specified with taskID')

              if filepath.startswith('/') or '../' in filepath:

                  raise koji.GenericError('invalid filepath: %s' % filepath)

          else:

              raise koji.GenericError('either rpmID or taskID and filepath must be specified')

          task.assertHost(host.id)

          scratchdir = koji.pathinfo.scratch()

          username = get_user(task.getOwner())['name']

          for reldir, files in to_list(results['files'].items()) + [('', results['logs'])]:

              for filename in files:

                  if reldir:

                  else:

                      relpath = filename

                  move_and_symlink(src, dest, create_dir=True)

          if rpm_results:

              for relpath in [rpm_results['srpm']] + rpm_results['rpms'] + \

                      rpm_results['logs']:

                  move_and_symlink(src, dest, create_dir=True)

      def moveWinBuildToScratch(self, task_id, results, rpm_results):

          task.assertHost(host.id)

          scratchdir = koji.pathinfo.scratch()

          username = get_user(task.getOwner())['name']

          for relpath in to_list(results['output'].keys()) + results['logs']:

              move_and_symlink(filename, dest, create_dir=True)

          if rpm_results:

              for relpath in [rpm_results['srpm']] + rpm_results['rpms'] + \

                      rpm_results['logs']:

                  move_and_symlink(filename, dest, create_dir=True)

      def moveImageBuildToScratch(self, task_id, results):

              workdir = koji.pathinfo.task(sub_results['task_id'])

              scratchdir = koji.pathinfo.scratch()

              username = get_user(task.getOwner())['name']

                  'task_%s' % sub_results['task_id'])

              for img in sub_results['files'] + sub_results['logs']:

                  logger.debug('renaming %s to %s' % (src, dest))

                  move_and_symlink(src, dest, create_dir=True)

              if 'rpmresults' in sub_results:

                  rpm_results = sub_results['rpmresults']

                  for relpath in [rpm_results['srpm']] + rpm_results['rpms'] + \

                          rpm_results['logs']:

                          rpm_results['task_id']), relpath)

                      move_and_symlink(src, dest, create_dir=True)

      def initBuild(self, data):

                  # This directory has a .pom file, so get the Maven group_id,

                  # artifact_id, and version from it and associate those with

                  # the artifacts in this directory

                  pom_info = koji.parse_pom(pom_path)

                  dir_maven_info = koji.pom_to_maven_info(pom_info)

              else:

                  if os.path.splitext(filename)[1] in ('.md5', '.sha1'):

                      # metadata, we'll recreate that ourselves

                      continue

                  if filename == 'maven-metadata.xml':

                      # We want the maven-metadata.xml to be present in the build dir

                      # so that it's a valid Maven repo, but we don't want to track it

                      # in the database because we regenerate it when creating tag repos.

                      # So we special-case it here.

                      _import_archive_file(filepath, destdir)

                      _generate_maven_metadata(destdir)

                      continue

          # move the logs to their final destination

          for log_path in maven_results['logs']:

                               build_info, subdir='maven')

          if rpm_results:

              if not archivetype:

                  # Unknown archive type, fail the build

                  raise koji.BuildError('unsupported file type: %s' % relpath)

              metadata['relpath'] = os.path.dirname(relpath)

              import_archive(filepath, build_info, 'win', metadata, buildroot_id=results['buildroot_id'])

              subdir = 'win'

              reldir = os.path.dirname(relpath)

              if reldir:

                               build_info, subdir=subdir)

          if rpm_results:

                  binfo = get_build(rpminfo['build_id'])

                  builddir = koji.pathinfo.build(binfo)

                  build_dirs[rpminfo['build_id']] = builddir

              rpmdata[bnp] = rpminfo

          # move the uploaded files

              rpmpath = rpminfo['_fullpath']

              bnp = fn

              bnplet = bnp[0].lower()

              koji.ensuredir(ddir)

              if os.path.exists(l_dst):

                  raise koji.GenericError("File already in repo: %s", l_dst)

              logger.debug("os.link(%r, %r)", rpmpath, l_dst)

          host.verify()

          Task(task_id).assertHost(host.id)

          check_user = False

      if create:

          koji.ensuredir(udir)

          if check_user:

              # assuming login was asserted earlier

              if os.path.exists(u_fn):

                  user_id = int(open(u_fn, 'r').read())

                  if context.session.user_id != user_id:

              else:

                  with open(u_fn, 'w') as fo:

                      fo.write(str(context.session.user_id))

  def get_verify_class(verify):

      if verify == 'md5':

      os.symlink(dst, src)

  def eventFromOpts(session, opts):

      """Determine event id from standard cli options

  import koji

  from koji.context import context

  from koji.plugin import callback

  from koji.util import rmtree

  import six.moves.configparser

  import fnmatch

      else:

          return

      try:

          if os.path.exists(tmpdir):

              rmtree(tmpdir)

          if len(poms) != 1:

              continue

          maven_info = koji.pom_to_maven_info(pom_info)

          maven_archives.append({'maven_info': maven_info,

      if not maven_archives:

          return

          for m in mocks:

              m.assert_not_called()

  class ConfigFileTestCase(unittest.TestCase):

      """Test config file reading functions"""