omit =

      /usr/*

      tests/*

      util/*

  [report]

  	coverage3 erase

  	PYTHONPATH=hub/.:plugins/hub/.:plugins/builder/.:plugins/cli/.:cli/. coverage3 run \

  	    --rcfile .coveragerc3 --source . \

  	@echo Full coverage report at file://${PWD}/htmlcov/index.html

  test-tarball:

  import tempfile

  import time

  import traceback

  import six.moves.xmlrpc_client

  import zipfile

  import rpm

  import six

  import koji

  import koji.auth

  import koji.db

      groupsdir = "%s/groups" % (repodir)

      koji.ensuredir(groupsdir)

      comps = koji.generate_comps(groups, expand_groups=True)

      #get build dirs

      relpathinfo = koji.PathInfo(topdir='toplink')

    </versioning>

  </metadata>

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

      _generate_maven_metadata(destdir)

  def dist_repo_init(tag, keys, task_opts):

      result = []

      if not os.path.exists(zippath):

          return result

      return result

  def _get_tarball_list(archive_id, tarpath):

      result = []

      if not os.path.exists(tarpath):

          return result

      return result

  def list_archive_files(archive_id, queryOpts=None, strict=False):

              path = os.path.join(workdir, directory, metadata)

              if not os.path.exists(path):

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

          self.raw_metadata = metadata

          self.metadata = parse_json(metadata, desc='metadata')

          return self.metadata

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

          koji.ensuredir(builddir)

          path = os.path.join(builddir, 'metadata.json')

              fo.write(self.raw_metadata)

      def prep_brs(self):

          raise koji.ImportError('SCM URLs for the task and build do not match: %s, %s' % \

                (task_info['request'][0], build_task_info['request'][0]))

      build_arches = set()

              if srpm != build_srpm:

                  raise koji.ImportError('task and build srpm names do not match: %s, %s' % \

                        (srpm, build_srpm))

              continue

          else:

      if not build_arches:

          raise koji.ImportError('no arch-specific rpms found for %s' % build['nvr'])

      task_arches = set([t['arch'] for t in tasks.values()])

      archiveinfo = {'buildroot_id': buildroot_id}

      archiveinfo['build_id'] = buildinfo['id']

      if metadata_only:

          archiveinfo['filename'] = filename

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

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

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

          archiveinfo['metadata_only'] = True

      else:

          archiveinfo['filename'] = filename

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

          # trust values computed on hub (CG_Importer.prep_outputs)

          if not fileinfo or not fileinfo.get('hub.checked_md5'):

              archiveinfo['checksum'] = m.hexdigest()

          else:

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

      A symlink pointing from the old location to the new location will

      be created.

      """

      if os.path.exists(final_path):

          raise koji.GenericError("Error importing archive file, %s already exists" % final_path)

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

              sumfile = mavenfile + ext

              if sumfile not in mavenfiles:

                  sum = sum_constr()

  def add_rpm_sig(an_rpm, sighdr):

      """Store a signature header for an rpm"""

      # - write to fs

      sigpath = "%s/%s" % (builddir, koji.pathinfo.sighdr(rinfo, sigkey))

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

      koji.plugin.run_callbacks('postRPMSign', sigkey=sigkey, sighash=sighash, build=binfo, rpm=rinfo)

  def _scan_sighdr(sighdr, fn):

          koji.splice_rpm_sighdr(sighdr, rpm_path, temp)

          ts = rpm.TransactionSet()

          ts.setVSFlags(0)  #full verify

      except:

          try:

              os.unlink(temp)

          else:

              os.unlink(signedpath)

      sigpath = "%s/%s" % (builddir, koji.pathinfo.sighdr(rinfo, sigkey))

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

      koji.splice_rpm_sighdr(sighdr, rpm_path, signedpath)

      if value is None:

          return value

      try:

      except Exception:

          if errstr is None:

              if desc is None:

          if not self.data and not self.rawdata:

              return "-- incomplete update: no assigns"

          parts = ['INSERT INTO %s ' % self.table]

          parts.append("(%s) " % ', '.join(columns))

          values = []

          for key in columns:

          parts = ['UPDATE %s SET ' % self.table]

          assigns = ["%s = %%(data.%s)s" % (key, key) for key in self.data]

          assigns.extend(["%s = (%s)" % (key, self.rawdata[key]) for key in self.rawdata])

          if self.clauses:

              parts.append('\nWHERE ')

          return ''.join(parts)

      def __repr__(self):

          if columns and aliases:

              if len(columns) != len(aliases):

                  raise Exception('column and alias lists must be the same length')

          else:

              self.colsByAlias = {}

          self.tables = tables

          self.joins = joins

          self.cursors = 0

          if values:

              self.values = values

                  col_str = 'count(*)'

          else:

              col_str = self._seqtostr(self.columns)

          join_str = self._joinstr()

          clause_str = self._seqtostr(self.clauses, sep=')\n   AND (')

          if clause_str:

          return '<QueryProcessor: columns=%r, aliases=%r, tables=%r, joins=%r, clauses=%r, values=%r, opts=%r>' % \

                 (self.columns, self.aliases, self.tables, self.joins, self.clauses, self.values, self.opts)

          if seq:

              return sep.join(seq)

          else:

              return ''

          if not os.path.isfile(filePath):

              raise koji.GenericError('no file "%s" output by task %i' % (fileName, taskID))

          # Let the caller handler any IO or permission errors

          return base64.encodestring(contents)

      listTaskOutput = staticmethod(list_task_output)

          for (cltime, clname, cltext) in zip(fields['changelogtime'], fields['changelogname'],

                                              fields['changelogtext']):

              cldate = datetime.datetime.fromtimestamp(cltime).isoformat(' ')

              if author and author != clname:

                  continue

                  results.append({'date': cldate, 'date_ts': cltime, 'author': clname, 'text': cltext})

          results = _applyQueryOpts(results, queryOpts)

      def cancelBuild(self, buildID):

          """Cancel the build with the given buildID

          else:

              return 1

          """Return a function to sort a list of maps by the given key.

          """

      def filterResults(self, methodName, *args, **kw):

          """Execute the XML-RPC method with the given name and filter the results

          order = filterOpts.get('order')

          if order:

          offset = filterOpts.get('offset')

          if offset is not None:

                  if context.session.user_id != user_id:

                      raise koji.GenericError("Invalid upload directory, not owner: %s" % orig_reldir)

              else:

      return os.path.join(udir, name)

  def get_verify_class(verify):

      start = time.time()

      if not context.session.logged_in:

          raise koji.ActionNotAllowed('you must be logged-in to upload a file')

      #XXX - already parsed by auth

      name = args['filename'][0]

      path = args.get('filepath', ('',))[0]

      def dump_datetime(self, value, write):

          # For backwards compatibility, we return datetime objects as strings

          value = value.isoformat(' ')

      dispatch[datetime.datetime] = dump_datetime

      else:

          faultString = msg

      response = dumps(Fault(faultCode, faultString))

      headers = [

          ('Content-Length', str(len(response))),

          ('Content-Type', "text/xml"),

              name = 'koji' + name

          elif not name.startswith('koji'):

              name = 'koji.' + name

          logging.getLogger(name).setLevel(level_code)

      logger = logging.getLogger("koji")

      # if KojiDebug is set, force main log level to DEBUG

          ]

          start_response('405 Method Not Allowed', headers)

          response = "Method Not Allowed\nThis is an XML-RPC server. Only POST requests are accepted."

          headers = [

              ('Content-Length', str(len(response))),

              ('Content-Type', "text/plain"),

                  response = h._wrap_handler(h.handle_upload, environ)

              else:

                  response = h._wrap_handler(h.handle_rpc, environ)

              headers = [

                  ('Content-Length', str(len(response))),

                  ('Content-Type', "text/xml"),

  %package hub

  Summary: Koji XMLRPC interface

  Group: Applications/Internet

  License: LGPLv2 and GPLv2

  # rpmdiff lib (from rpmlint) is GPLv2 (only)

  Requires: httpd

  Requires: %{name} = %{version}-%{release}

  # we need the python2 lib here

  Requires: python2-%{name} = %{version}-%{release}

  koji-hub is the XMLRPC interface to the koji database

  %package hub-plugins

  Summary: Koji hub plugins

  Group: Applications/Internet

  License: LGPLv2

  Requires: python-qpid >= 0.7

  Requires: python-qpid-proton

  %endif

  Requires: cpio

  Plugins to the koji XMLRPC interface

  %package builder-plugins

  Summary: Koji builder plugins

  Group: Applications/Internet

  rm -rf $RPM_BUILD_ROOT

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

  %if 0%{with python3}

  # alter python interpreter in koji CLI

  sed -i 's/\#\!\/usr\/bin\/python2/\#\!\/usr\/bin\/python3/' $RPM_BUILD_ROOT/usr/bin/koji

  %endif

  %files hub

  %defattr(-,root,root)

  %config(noreplace) /etc/httpd/conf.d/kojihub.conf

  %dir /etc/koji-hub

  %config(noreplace) /etc/koji-hub/hub.conf

  %dir /etc/koji-hub/hub.conf.d

  %defattr(-,root,root)

  %dir /etc/koji-hub/plugins

  %config(noreplace) /etc/koji-hub/plugins/*.conf

  %files builder-plugins

  %defattr(-,root,root)

  %dir /etc/kojid/plugins

      return hdr

  def get_header_field(hdr, name, src_arch=False):

      """Extract named field from an rpm header"""

      name = name.upper()

              result = []

          elif isinstance(result, six.integer_types):

              result = [result]

      sizetags = ('SIZE', 'ARCHIVESIZE', 'FILESIZES', 'SIGSIZE')

      if name in sizetags and (result is None or result == []):

              # no such header

              pass

  def _get_header_field(hdr, name):

  from __future__ import absolute_import

  import logging

  import psycopg2

  # import psycopg2.extensions

  # # don't convert timestamp fields to DateTime objects

  # del psycopg2.extensions.string_types[1082]

  # del psycopg2.extensions.string_types[1083]

  # del psycopg2.extensions.string_types[1266]

  import time

  import traceback

  from . import context

  POSITIONAL_RE = re.compile(r'%[a-z]')

  NAMED_RE = re.compile(r'%\(([^\)]+)\)[a-z]')

  		echo "ERROR: A destdir is required"; \

  		exit 1; \

  	fi

  	if [ "$(PYMAJORVER)" == "2" ] ; then \

  		mkdir -p $(DESTDIR)/$(BUILDERPLUGINDIR); \

  		install -p -m 644 $(BUILDERFILES) $(DESTDIR)/$(BUILDERPLUGINDIR); \

  		$(PYTHON) -c "import compileall; compileall.compile_dir('$(DESTDIR)/$(BUILDERPLUGINDIR)', 1, '$(BUILDERPLUGINDIR)', 1)"; \

  		mkdir -p $(DESTDIR)/$(BUILDERCONFDIR); \

  		install -p -m 644 $(BUILDERCONFFILES) $(DESTDIR)/$(BUILDERCONFDIR); \

  	fi

  {

      "inserts": [

          [

                  "size": 36

              {}

          [

              {

                  "arch": "x86_64"

              {}

          [