import simplejson as json

      except ImportError:

          json = None

  import base64

  import dateutil.parser

  import koji

  import koji.util

  import fnmatch

  import logging

  import os

  import re

  import pprint

  import random

  import socket

  import stat

  import string

  import time

  import traceback

  try:

      import libcomps

  except ImportError:  # pragma: no cover

          import yum.comps as yumcomps

      except ImportError:

          yumcomps = None

  # fix OptionParser for python 2.3 (optparse verion 1.4.1+)

              u'नमस्कार',

              u'안녕하세요')

  def _(args):

      """Stub function for translation"""

      return args

  def get_epilog_str(progname=None):

      if progname is None:

          progname = os.path.basename(sys.argv[0]) or 'koji'

      epilog_str = '''

  Try "%(progname)s --help" for help about global options

  Try "%(progname)s help" to get all available commands

      # load local config

      try:

          result = koji.read_config(options.profile, user_config=options.configFile)

          parser.error(e.args[0])

          assert False  # pragma: no cover

      # update options according to local config

          if getattr(options, name, None) is None:

              setattr(options, name, value)

          error = None

          try:

              result = self.session.getTaskResult(self.id)

          if error is None:

              # print("%s: complete" % self.str())

              # We already reported this task as complete in update()

      open = 0

      failed = 0

      done = 0

          status = tasks[task_id].info['state']

          if status == koji.TASK_STATES['FAILED']:

              failed += 1

      print("  %d free  %d open  %d done  %d failed" % (free, open, done, failed))

  def display_task_results(tasks):

          state = task.info['state']

          task_label = task.str()

              tasks[task_id] = TaskWatcher(task_id,session,quiet=quiet)

          while True:

              all_done = True

                  changed = task.update()

                  if not task.is_done():

                      all_done = False

                          rv = 1

                  for child in session.getTaskChildren(task_id):

                      child_id = child['id']

                          tasks[child_id] = TaskWatcher(child_id, session, task.level + 1, quiet=quiet)

                          tasks[child_id].update()

                          # If we found new children, go through the list again,

          if tasks and not quiet:

              progname = os.path.basename(sys.argv[0]) or 'koji'

              tlist = ['%s: %s' % (t.str(), t.display_state(t.info))

              print( \

  """Tasks still running. You can continue to watch with the '%s watch-task' command.

  Running Tasks:

              output = list_task_output_all_volumes(session, task_id)

              # convert to list of (file, volume)

              files = []

                  files += [(filename, volume) for volume in volumes]

              if opts.log:

      """List task output with all volumes, or fake it"""

      try:

          return session.listTaskOutput(task_id, all_volumes=True)

          if 'got an unexpected keyword argument' not in str(e):

              raise

      # otherwise leave off the option and fake it

      activate_session(session)

      vals = {}

          if val is not None:

              vals[key] = val

      if 'arches' in vals:

  def _running_in_bg():

      try:

          return (not os.isatty(0)) or (os.getpgrp() != os.tcgetpgrp(0))

          return True

  def handle_build(options, session, args):

          try:

              params = koji.util.parse_maven_param(build_opts.inis, scratch=build_opts.scratch,

                                                   section=build_opts.section)

              parser.error(e.args[0])

          if opts.pop('type', 'maven') != 'maven':

          source = opts.pop('scmurl')

      else:

          source = args[1]

          try:

              params = koji.util.parse_maven_param(build_opts.inis, scratch=build_opts.scratch,

                                                   section=build_opts.section)

              parser.error(e.args[0])

          if opts.get('type') != 'wrapper':

          url = opts['scmurl']

          package = opts['buildrequires'][0]

          target_info = session.getBuildTarget(target, strict=True)

              opts[key] = val

      try:

          builds = koji.util.parse_maven_chain(args[1:], scratch=opts.get('scratch'))

          parser.error(e.args[0])

      priority = None

      if build_opts.background:

  def linked_upload(localfile, path, name=None):

      """Link a file into the (locally writable) workdir, bypassing upload"""

      try:

          if name is None:

              name = os.path.basename(localfile)

              nvr = "%(name)s-%(version)s-%(release)s" % koji.parse_NVRA(data['sourcerpm'])

          to_import.setdefault(nvr,[]).append((path,data))

      builds_missing = False

      nvrs.sort()

      for nvr in nvrs:

          to_import[nvr].sort()

          sys.stdout.flush()

          try:

              session.importRPM(serverdir, os.path.basename(path))

              print(_("\nError importing: %s" % str(e).splitlines()[-1]))

              sys.stdout.flush()

          else:

          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

              #that the build was recently untagged from

              tags.setdefault(entry['tag_name'], 1)

          if options.debug:

          for tag_name in tags:

              if tag_name == options.trashcan_tag:

                  if options.debug:

          build_space = 0

          if not by_sig and options.debug:

              print("(build has no signatures)")

              mycount = 0

              archdirs = {}

              sigdirs = {}

                          print("Unlinking: %s" % signedpath)

                      try:

                          os.unlink(signedpath)

                          print("Error removing %s: %s" % (signedpath, e))

                          print("This script needs write access to %s" % koji.BASEDIR)

                          continue

                          print("Removing dir: %s" % dir)

                      try:

                          os.rmdir(dir)

                          print("Error removing %s: %s" % (signedpath, e))

              if len(sigdirs) == 1:

                  if options.test:

                      print("Would have removed dir: %s" % dir)

                  else:

                          print("Removing dir: %s" % dir)

                      try:

                          os.rmdir(dir)

                          print("Error removing %s: %s" % (signedpath, e))

              elif len(sigdirs) > 1:

                  print("Warning: more than one signature dir for %s: %r" % (sigkey, sigdirs))

          sys.stdout.write(_("importing %s... ") % nvr)

          try:

              session.importBuildInPlace(data)

              print(_("\nError importing: %s" % str(e).splitlines()[-1]))

              sys.stdout.flush()

          else:

                  dstgroups[group['name']] = group

          #construct to-do lists.

          paddlist = [] # list containing new packages to be added from src tag

              if package_name not in dstpkgs:

                  paddlist.append(pkg)

          paddlist.sort(key = lambda x: x['package_name'])

          pdellist = [] # list containing packages no more present in dst tag

              if package_name not in srcpkgs:

                  pdellist.append(pkg)

          pdellist.sort(key = lambda x: x['package_name'])

          baddlist = [] # list containing new builds to be added from src tag

              if nvr not in dstlblds:

                  baddlist.append(lbld)

          baddlist.sort(key = lambda x: x['package_name'])

          bdellist = [] # list containing new builds to be removed from src tag

              if nvr not in srclblds:

                  bdellist.append(lbld)

          bdellist.sort(key = lambda x: x['package_name'])

          gaddlist = [] # list containing new groups to be added from src tag

              if grpname not in dstgroups:

                  gaddlist.append(group)

          gdellist = [] # list containing groups to be removed from src tag

              if grpname not in srcgroups:

                  gdellist.append(group)

          grpchanges = {} # dict of changes to make in shared groups

              if grpname in dstgroups:

                  grpchanges[grpname] = {'adds':[], 'dels':[]}

                  # Store whether group is inherited or not

          if depth < currtag['currdepth']:

              outspacing = depth - outdepth

              sys.stdout.write(' ' * (outspacing * 3 - 1))

              outdepth = depth

      sys.stdout.write(' ' * ((currtag['currdepth'] - outdepth) * 3 - 1))

      if siblings:

      else:

      if reverse:

          sys.stdout.write('%(name)s (%(tag_id)i)\n' % currtag)

      else:

          else:

              return '%s.name' % key

      if edit:

          keys.sort()

          y = other[-1]

          for key in keys:

                  continue

              print("    %s: %s -> %s" % (key, x[key], y[key]))

      elif create and options.verbose and table != 'tag_listing':

          keys.sort()

          # the table keys have already been represented in the base format string

          also_hidden = list(_table_keys[table])

                  kwargs['afterEvent'] = last_event

  def _handleMap(lines, data, prefix=''):

          if key != '__starstar':

              lines.append('  %s%s: %s' % (prefix, key, val))

              _handleOpts(lines, params[4])

      elif method == 'chainmaven':

          lines.append("Builds:")

              lines.append("  " + package)

              _handleMap(lines, opts, prefix="  ")

          lines.append("Build Target: %s" % params[1])

              print("Include all Maven archives?: %s" % (info['maven_include_all'] and 'yes' or 'no'))

          if 'extra' in info:

              print("Tag options:")

              keys.sort()

              for key in keys:

                  print("  %s : %s" % (key, pprint.pformat(info['extra'][key])))

          # We want the latest build, not a specific build

          try:

              builds = session.listTagged(suboptions.latestfrom, latest=True, package=build, type=suboptions.type)

              print("Error finding latest build: %s" % data)

              return 1

          if not builds:

              url = pathinfo.build(info) + '/' + fname

              urls.append((url, os.path.basename(fname)))

      for url, relpath in urls:

          if '/' in relpath:

              koji.ensuredir(os.path.dirname(relpath))

  def anon_handle_download_logs(options, session, args):

              targets = session.getBuildTargets(destTagID=tag_info['id'])

              if targets:

                  maybe = {}.fromkeys([t['build_tag_name'] for t in targets])

                  maybe.sort()

                  print("Suggested tags: %s" % ', '.join(maybe))

              return 1

      if not u:

          print("Not authenticated")

          u = {'name' : 'anonymous user'}

      print("")

      print("You are using the hub at %s" % session.baseurl)

      authtype = u.get('authtype', getattr(session, 'authtype', None))

              kwargs['new_chroot'] = True

          task_id = session.runroot(tag, arch, command, **kwargs)

          if 'Invalid method' in str(e):

              print("* The runroot plugin appears to not be installed on the"

                    " koji hub.  Please contact the administrator.")

      try:

          task_id = session.saveFailedTree(br_id, opts.full)

          if 'Invalid method' in m:

              print(_("* The save_failed_tree plugin appears to not be "

                      "installed on the koji hub.  Please contact the "

      chosen = set(args)

      if options.admin:

          chosen.add('admin')

      unavail = chosen - avail

      for arg in unavail:

          print("No such help category: %s" % arg)

  def list_commands(categories_chosen=None):

      if categories_chosen is None or "all" in categories_chosen:

      else:

          # copy list since we're about to modify it

          categories_chosen = list(categories_chosen)

      categories_chosen.sort()

      handlers = []

          if name.startswith('handle_'):

              alias = name.replace('handle_','')

              alias = alias.replace('_','-')

                  session.krb_login(principal=options.principal, keytab=options.keytab, proxyuser=options.runas)

              else:

                  session.krb_login(proxyuser=options.runas)

              warn(_("Could not connect to Kerberos authentication service: %s") % e.args[1])

              if krbV is not None and isinstance(e, krbV.Krb5Error):

                  error(_("Kerberos authentication failed: %s (%s)") % (e.args[1], e.args[0]))

              else:

   * ``python-krbV``

   * ``python-mock``

   * ``python-simplejson``

   * ``python-psycopg2``

   * ``python-requests``

   * ``python-qpid-proton``

  Requires: pyOpenSSL

  Requires: python-requests

  Requires: python-requests-kerberos

  Requires: python-dateutil

  BuildRequires: python

  %if %{use_systemd}

  try:

      import krbV

  except ImportError:  # pragma: no cover

      sys.stderr.write("Warning: Could not install krbV module. Kerberos support will be disabled.\n")

      sys.stderr.flush()

  import base64

  import datetime

  import errno

  from fnmatch import fnmatch

  import imp

  import logging

  import logging.handlers

  SSL_Error = None

  try:

      from OpenSSL.SSL import Error as SSL_Error

  except Exception:  #pragma: no cover

  import re

  try:

      import requests

      requests = None

  try:

      from requests_kerberos import HTTPKerberosAuth

      HTTPKerberosAuth = None

  import rpm

  import shutil

  import time

  import traceback

  import urllib

  import warnings

  import xml.sax

  import xml.sax.handler

  PROFILE_MODULES = {}  # {module_name: module_instance}

      code = getattr(fault, 'faultCode', None)

      if code is None:

          return fault

          if isinstance(v, type(Exception)) and issubclass(v, GenericError) and \

                  code == getattr(v, 'faultCode', None):

              ret = v(fault.faultString)

          desc: the description of the exception (docstring)

      """

      ret = []

          if isinstance(v, type(Exception)) and issubclass(v, GenericError):

              code = getattr(v, 'faultCode', None)

              if code is None:

      """Load xmlrpc data from a string, but catch faults"""

      try:

          return loads(s)

  ## BEGIN kojikamid dup

          print("Store at offset %d (%0x)" % (store, store))

          #sort entries by offset, dtype

          #also rearrange: tag, dtype, offset, count -> offset, dtype, tag, count

          next = store

          #map some rpmtag codes

          tags = {}

              if name.startswith('RPMTAG_') and isinstance(code, int):

                  tags[code] = name[7:].lower()

          for entry in order:

          xml.sax.parseString(contents, handler)

      for field in fields:

              raise GenericError('could not extract %s from POM: %s' % (field, (path or '<contents>')))

      return values

      if opts.get('maven_opts'):

          mavenrc = 'export MAVEN_OPTS="%s"\n' % ' '.join(opts['maven_opts'])

      if opts.get('maven_envs'):

              mavenrc += 'export %s="%s"\n' % (name, val)

      if mavenrc:

          files['etc/mavenrc'] = mavenrc

  """ % locals())

      parts.append("\n")

          parts.append("config_opts[%r] = %r\n" % (key, value))

      parts.append("\n")

          parts.append("config_opts['plugin_conf'][%r] = %r\n" % (key, value))

      parts.append("\n")

      if bind_opts:

          # This line is REQUIRED for mock to work if bind_opts defined.

          parts.append("config_opts['internal_dev_setup'] = False\n")

                  parts.append("config_opts['plugin_conf']['bind_mount_opts'][%r].append((%r, %r))\n" % (key, mnt_src, mnt_dest))

          parts.append("\n")

          parts.append("config_opts['macros'][%r] = %r\n" % (key, value))

      parts.append("\n")

          parts.append("config_opts['files'][%r] = %r\n" % (key, value))

      return ''.join(parts)

          rv += "Frame %s in %s at line %s\n" % (frame.f_code.co_name,

                                                 frame.f_code.co_filename,

                                                 frame.f_lineno)

              rv += "  %20s = " % key

              # we must _absolutely_ avoid propagating eceptions, and str(value)

              # COULD cause any exception, so we MUST catch any...:

      on options"""

      if topurl:

          url = "%s/%s" % (topurl, relpath)

          fo = tempfile.TemporaryFile(dir=tempdir)

          shutil.copyfileobj(src, fo)

          src.close()

      configs = []

      try:

          conf_dir_contents = os.listdir(dir_name)

          if exception.errno != errno.ENOENT:

              raise

      else:

  class PathInfo(object):

      # ASCII numbers and upper- and lower-case letter for use in tmpdir()

      def __init__(self, topdir=None):

          self._topdir = topdir

                  pass

          if not krbV:

                  "Please install python-krbV to use kerberos."

              )

          """Get the Kerberos principal of the server we're connecting

          to, based on baseurl."""

          if self.opts.get('krb_rdns', True):

              servername = socket.getfqdn(host)

          else:

      def gssapi_login(self, proxyuser=None):

          if not HTTPKerberosAuth:

                  "Please install python-requests-kerberos to use GSSAPI."

              )

          # force https

          old_baseurl = self.baseurl

          if uri[0] != 'https':

              self.baseurl = 'https://%s%s' % (uri[1], uri[2])

          # when API is changed

          # force https

          if uri[0] != 'https':

              self.baseurl = 'https://%s%s' % (uri[1], uri[2])

              sinfo = self.sinfo.copy()

              sinfo['callnum'] = self.callnum

              self.callnum += 1

          elif name == 'sslLogin':

              handler = self.baseurl + '/ssllogin'

          else:

          for i in (0, 1):

              try:

                  return self._sendOneCall(handler, headers, request)

                  if i or not is_conn_error(e):

                      raise

                  self.logger.debug("Connection Error: %s", e)

                  # note that, for logged-in sessions the server should tell us (via a RetryError fault)

                  # if the call cannot be retried. For non-logged-in sessions, all calls should be read-only

                  # and hence retryable.

                      #try to convert the fault to a known exception

                      err = convertFault(fault)

                      if isinstance(err, ServerOffline):

                  except (SystemExit, KeyboardInterrupt):

                      #(depending on the python version, these may or may not be subclasses of Exception)

                      raise

                      tb_str = ''.join(traceback.format_exception(*sys.exc_info()))