import glob

  import grp

  import io

  import logging

  import logging.handlers

  import os

          output = koji.genMockConfig(self.name, self.br_arch, managed=True, **opts)

          # write config

              fo.write(output)

      def _repositoryEntries(self, pi, plugin=False):

  </settings>

  """

          settings = settings % locals()

      def mock(self, args):

          """Run mock"""

                              ts_name = '%s-ts.log' % fname

                              fpath = os.path.join(resultdir, ts_name)

                              if os.path.exists(fpath):

                                      lines = ts_file.readlines()

                                      if lines:

                                          last = int(lines[-1].split()[1])

                                          ts_offsets[fname] = last

                              else:

                                      ts_file.write('%.0f 0\n' % time.time())

                              logs[ts_name] = (None, None, 0, fpath)

                  if workdir and mocklog not in logs:

                              ts_name = '%s-ts.log' % mocklog

                              fpath = os.path.join(workdir, ts_name)

                              if os.path.exists(fpath):

                                      lines = ts_file.readlines()

                                      if lines:

                                          last = int(lines[-1].split()[1])

                                          ts_offsets[mocklog] = last

                              else:

                                      ts_file.write('%.0f 0\n' % time.time())

                              logs[ts_name] = (None, None, 0, fpath)

                          ts_offsets.setdefault(fname, 0)

                          if ts_offsets[fname] < position:

                              fpath = os.path.join(resultdir, '%s-ts.log' % fname)

                                  ts_file.write('%.0f %i\n' % (time.time(), position))

                              ts_offsets[fname] = position

                      incremental_upload(self.session, fname, fd, uploadpath, logger=self.logger)

          if rpmdiff_hash[self.id]:

              log_name = 'noarch_rpmdiff.json'

              noarch_hash_path = os.path.join(broot.workdir, log_name)

          self.logger.debug("rpms: %r" % rpm_files)

          self.logger.debug("srpms: %r" % srpm_files)

              tgt[field] = src.get(field)

      def spec_sanity_checks(self, filename):

          for tag in ("Packager", "Distribution", "Vendor"):

              if re.match("%s:" % tag, spec, re.M):

                  raise koji.BuildError("%s is not allowed to be set in spec file" % tag)

          kskoji = os.path.join(broot.tmpdir(), 'koji-image-%s-%i.ks' %

                                (target_info['build_tag_name'], self.id))

          koji.ensuredir(broot.tmpdir())

              outfile.write(str(self.ks.handler))

          # put the new ksfile in the output directory

          Using iso9660 from pycdio, get the file manifest of the given image,

          and save it to the text file manifile.

          """

          if not fd:

              raise koji.GenericError(

                  'Unable to open manifest file (%s) for writing!' % manifile)

          Using iso9660 from pycdio, get the file manifest of the given image,

          and save it to the text file manifile.

          """

          if not fd:

              raise koji.GenericError(

                  'Unable to open manifest file (%s) for writing!' % manifile)

              an absolute path to the kickstart file we wrote

          """

          kspath = os.path.join(self.workdir, ksname)

              outfile.write(str(ksobj.handler))

          # put the new ksfile in the output directory

          edriver = newxml.getElementsByTagName('driver')[0]

          edriver.setAttribute('type', format)

          xml_path = os.path.join(self.workdir, filename)

              xmlfd.write(newxml.toprettyxml())

          return xml_path

          ApplicationConfiguration(configuration=config)

          tdl_path = os.path.join(self.workdir, 'tdl-%s.xml' % self.arch)

              tdl.write(template)

          self.uploadFile(tdl_path)

              tops['tempdir'] = self.workdir

              final_path = os.path.join(self.workdir, os.path.basename(filepath))

              with koji.openRemoteFile(filepath, **tops) as remote_fileobj:

                      shutil.copyfileobj(remote_fileobj, final_fileobj)

          self.logger.debug('uploading retrieved file from here: %s' % final_path)

          self.uploadFile(final_path)  # upload the original ks file

              # Factory doesn't attempt to modify a disk image after it is COMPLETE so

              # this will work safely on read-only NFS mounts

              factory_base_image.data = diskimage_full

              factory_base_image.status = 'COMPLETE'

              # Now save it

              pim.save_image(factory_base_image)

              # Factory doesn't attempt to modify a disk image after it is COMPLETE so

              # this will work safely on read-only NFS mounts

              factory_base_image.data = diskimage_full

              factory_base_image.status = 'COMPLETE'

              # Now save it

              pim.save_image(factory_base_image)

          rm = ReservationManager()

          rm._listen_port = rm.MIN_PORT + self.id % (rm.MAX_PORT - rm.MIN_PORT)

          results_loc = opts.get('results_loc', None)

          if results_loc[0] != "/":

              results_loc = "/" + results_loc

                      pim = PersistentImageManager.default_manager()

                      pim.add_image(target_image)

                      target.target_image = target_image

                          f.write("Mock build from task ID: %s" % self.id)

                      target_image.status = 'COMPLETE'

                  else:

      _taskWeight = 1.0

      def spec_sanity_checks(self, filename):

          for tag in ("Packager", "Distribution", "Vendor"):

              if re.match("%s:" % tag, spec, re.M):

                  raise koji.BuildError("%s is not allowed to be set in spec file" % tag)

          if external_repos:

              self.merge_repos(external_repos, arch, groupdata)

          elif pkglist is None:

                  fo.write("This repo is empty because its tag has no content for this arch\n")

          uploadpath = self.getUploadDir()

                  zck_dict_dir=opts.get('zck_dict_dir'))

          if len(self.kojipkgs) == 0:

              fn = os.path.join(self.repodir, "repodata", "EMPTY_REPO")

                  fp.write("This repo is empty because its tag has no content "

                           "for this arch\n")

      def upload_repo_manifest(self):

          """Upload a list of the repo files we've uploaded"""

          fn = '%s/repo_manifest' % self.workdir

          self.session.uploadWrapper(fn, self.uploadpath)

      def do_createrepo(self, repodir, pkglist, groupdata, oldpkgs=None,

          # read pkgs data from multilib repo

          ml_pkgfile = os.path.join(mldir, 'kojipkgs')

          # step 1: figure out which packages are multilib (should already exist)

          dnfbase = dnf.Base()

          # step 3: proceed with dnf config and set up

          yconfig_path = os.path.join(dnfdir, 'dnf.conf-koji-%s' % arch)

              f.write(dnfconfig)

          self.session.uploadWrapper(yconfig_path, self.uploadpath,

                                     os.path.basename(yconfig_path))

          if len(fs_missing) > 0:

              missing_log = os.path.join(self.workdir, 'missing_multilib.log')

                  outfile.write('The following multilib files were missing:\n')

                  for ml_path in fs_missing:

                      outfile.write(ml_path + '\n')

          # report problems

          if len(fs_missing) > 0:

              missing_log = os.path.join(self.workdir, 'missing_files.log')

                  outfile.write('Some rpm files were missing.\n'

                                'Most likely, you want to create these signed copies.\n\n'

                                'Missing files:\n')

          if sig_missing:

              # log missing signatures and possibly error

              missing_log = os.path.join(self.workdir, 'missing_signatures.log')

                  outfile.write('Some rpms were missing requested signatures.\n')

                  if opts['skip_missing_signatures']:

                      outfile.write('The skip_missing_signatures option was specified, so '

              else:

                  pkgs.append('Packages/%s/%s\n' % (bnplet, bnp))

              for line in pkgs:

                  fo.write(line)

          for subrepo in subrepo_pkgs:

              koji.ensuredir('%s/%s' % (self.repodir, subrepo))

                  for line in subrepo_pkgs[subrepo]:

                      fo.write(line)

      def write_kojipkgs(self):

          filename = os.path.join(self.repodir, 'kojipkgs')

  class WaitrepoTask(BaseTaskHandler):

                      include_srpms[srpm_name] = (pkg.sourcerpm, pkg.repoid)

          pkgorigins = os.path.join(self.yumbase.conf.cachedir, 'pkgorigins')

          seen_rpms = {}

          for repo in repos:

                      pkg._return_remote_location = make_const_func(loc)

          pkgorigins = os.path.join(self.yumbase.conf.cachedir, 'pkgorigins')

          seen_rpms = {}

          for repo in repos:

      opts = parse_args(args)

      if opts.blocked:

          blocked = dict([(b.strip(), 1) for b in blocked_list])

      else:

          blocked = {}

              opts['tag_macros'][macro] = buildcfg['extra'][key]

      output = koji.genMockConfig(name, arch, **opts)

      if options.ofile:

              fo.write(output)

      else:

          print(output)

      if json is None:

          parser.error(_("Unable to find json module"))

      activate_session(session, goptions)

      if 'output' not in metadata:

          print(_("Metadata contains no output"))

          sys.exit(1)

      # (with the modification that we check to see if the build was latest within

      # the last N days)

      if options.ignore_tag_file:

              options.ignore_tag.extend([line.strip() for line in fo.readlines()])

      if options.protect_tag_file:

              options.protect_tag.extend([line.strip() for line in fo.readlines()])

      if options.debug:

          options.verbose = True

          full_filename = os.path.normpath(os.path.join(task_log_dir, FAIL_LOG))

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

          sys.stdout.write("Writing: %s\n" % full_filename)

              fo.write(content)

      def download_log(task_log_dir, task_id, filename, blocksize=102400, volume=None):

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

      koji.ensuredir(groupsdir)

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

          fo.write(comps)

      # write repo info to disk

          'with_separate_src': with_separate_src,

          'with_debuginfo': with_debuginfo,

      }

          json.dump(repo_info, fp, indent=2)

      # get build dirs

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

          top_link = joinpath(archdir, 'toplink')

          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')

    </versioning>

  </metadata>

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

          mdfile.write(contents)

      _generate_maven_metadata(destdir)

          'volume': volume,

          'task_opts': task_opts,

      }

      # note: we need to match args from the other postRepoInit callback

      koji.plugin.run_callbacks('postRepoInit', tag=tinfo, with_src=False,

                                with_debuginfo=False, event=event, repo_id=repo_id,

      result = []

      if not os.path.exists(tarpath):

          return result

          for entry in archive:

              filename = koji.fixEncoding(entry.name)

              result.append({'archive_id': archive_id,

      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]

              path = joinpath(workdir, directory, metadata)

              if not os.path.exists(path):

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

                  metadata = fo.read()

          self.raw_metadata = metadata

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

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

          koji.ensuredir(builddir)

          path = joinpath(builddir, 'metadata.json')

              fo.write(self.raw_metadata)

      def prep_brs(self):

                          if not content:

                              break

                          sum.update(content)

                      sumobj.write(sum.hexdigest())

          fn = '%s/%s/repo_manifest' % (workdir, uploadpath)

          if not os.path.isfile(fn):

              raise koji.GenericError('Missing repo manifest')

          # Read package data

          fn = '%s/%s/kojipkgs' % (workdir, uploadpath)

          if not os.path.isfile(fn):

              raise koji.GenericError('Missing kojipkgs file')

          # Figure out where to send the uploaded files

          file_moves = []

              # assuming login was asserted earlier

              u_fn = joinpath(udir, '.user')

              if os.path.exists(u_fn):

                  if context.session.user_id != user_id:

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

                                              orig_reldir)

              else:

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

      return joinpath(udir, name)

  import errno

  import hashlib

  import imp

  import logging

  import logging.handlers

  import optparse

      values = {}

      handler = POMHandler(values, fields)

      if path:

      if not contents:

          raise GenericError(

      return ''.join(['%02x' % _ord(x) for x in s])

  def make_groups_spec(grplist, name='buildsys-build', buildgroup=None):

      """Return specfile contents representing the group"""

      if buildgroup is None:

      if opts.get('use_host_resolv', False) and os.path.exists('/etc/hosts'):

          # if we're setting up DNS,

          # also copy /etc/hosts from the host

      mavenrc = ''

      if opts.get('maven_opts'):

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

          downloadFile(url, path=relpath, fo=fo)

      elif topdir:

          fn = "%s/%s" % (topdir, relpath)

      else:

          raise GenericError("No access method for remote file: %s" % relpath)

      return fo

      """ Try to read /proc/cpuinfo ... if we can't ignore errors (ie. proc not

          mounted). """

      try:

      except Exception:

          return []

  def getCanonArch(skipRpmPlatform=0):

      if not skipRpmPlatform and os.access("/etc/rpm/platform", os.R_OK):

          try:

              (arch, vendor, opersys) = line.split("-", 2)

              return arch

          except Exception:

              fn = "%s/%s" % (configdir, f)

              if not os.path.isfile(fn):

                  continue

              id = None

              name = None

              for n in range(10):

              proc_path = '/proc/%i/stat' % pid

              if not os.path.isfile(proc_path):

                  return None

              procstats = [not field.isdigit() and field or int(field)

                           for field in proc_file.read().split()]

              proc_file.close()

              cmd_path = '/proc/%i/cmdline' % pid

              if not os.path.isfile(cmd_path):

                  return None

              procstats[1] = cmd_file.read().replace('\0', ' ').strip()

              cmd_file.close()

              if not procstats[1]:

          self.logger.info('New runroot')

          self.logger.info("Runroot mounts: %s" % mounts)

          fn = '%s/tmp/runroot_mounts' % rootdir

              logfile = "%s/do_mounts.log" % self.workdir

              uploadpath = self.getUploadDir()

              error = None

          mounts = set()

          fn = '%s/tmp/runroot_mounts' % rootdir

          if os.path.exists(fn):

                  for line in fslog.readlines():

                      mounts.add(line.strip())

          # also, check /proc/mounts just in case

      def load_calls(self, name):

          fn = os.path.join(os.path.dirname(__file__), 'data/calls', name,'calls.json')

          for call in data:

              key = self._munge([call['method'], call['args'], call['kwargs']])

              self._testcalls[key] = call

          # task_info['id'], method, params, self.session, self.options

          task_id = 999

          fn = os.path.join(os.path.dirname(__file__), 'data/calls', 'build_notif_1', 'params.json')

          self.session = MyClientSession('https://koji.example.com/kojihub')

          self.session.load_calls('build_notif_1')

          self.options.from_addr = "koji@example.com"

      @mock.patch('koji_cli.commands._running_in_bg', return_value=False)

      @mock.patch('koji_cli.commands.linked_upload')

      @mock.patch('koji_cli.commands.activate_session')

      def test_handle_import_cg(

              self,

              json_mock,

              activate_session=None)

          # Case 2. JSON module does not exist

          metadata = {

              'output': [

          with mock.patch(utils.get_builtin_open()):

              with mock.patch('os.path.exists', new=self.mock_os_path_exists):

                      # Case 3. metafile doesn't have output section

                      json_mock.load.return_value = {}

          fobj = mock.MagicMock()

          openf.return_value.__enter__.return_value = fobj

          anon_handle_mock_config(options, session, arguments)

          fobj.write.assert_called_once_with(self.mock_output)

          gen_config_mock.assert_called_with(

              self.progname, arch, **opts)

  from mock import call

  from six.moves import range

  from koji_cli.lib import watch_tasks

  from .fakeclient import FakeClientSession, RecordingClientSession

          if self.recording:

              # save recorded calls

              if self.record_file:

              else:

                  json.dump(self.session.get_calls(), sys.stderr, indent=4)

              self.recording = False

      def test_watch_tasks(self, stdout):

          # self.setup_record('foo.json')

          cfile = os.path.dirname(__file__) + '/data/calls/watchtasks1.json'

          self.session.load_calls(cdata)

          rv = watch_tasks(self.session, [1188], quiet=False, poll_interval=0,

                           topurl=self.options.topurl)

      def test_watch_tasks_fail(self, stdout, sleep):

          # self.setup_record('foo.json')

          cfile = os.path.dirname(__file__) + '/data/calls/watchtasks2.json'

          self.session.load_calls(cdata)

          rv = watch_tasks(self.session, [1208], quiet=False, poll_interval=5, topurl=None)

          self.assertEqual(rv, 1)

          """Raise KeyboardInterrupt inner watch_tasks.

          Raising it by SIGNAL might be better"""

          cfile = os.path.dirname(__file__) + '/data/calls/watchtasks2.json'

          self.session.load_calls(cdata)

          sleep.side_effect = [None] * 10  + [KeyboardInterrupt]

          with self.assertRaises(KeyboardInterrupt):

      def test_watch_tasks_with_keyboardinterrupt_handler(self, stdout, sleep):

          """Raise KeyboardInterrupt inner watch_tasks with a ki_handler"""

          cfile = os.path.dirname(__file__) + '/data/calls/watchtasks2.json'

          self.session.load_calls(cdata)

          sleep.side_effect = [None] * 10 + [KeyboardInterrupt]

      def set_up_files(self, name):

          datadir = os.path.join(os.path.dirname(__file__), 'data/image', name)

          # load image result data for our test build

          for arch in data:

              taskdir = koji.pathinfo.task(data[arch]['task_id'])

              os.makedirs(taskdir)

              filenames = data[arch]['files'] +  data[arch]['logs']

              for filename in filenames:

                  path = os.path.join(taskdir, filename)

                      fp.write('Test file for %s\n%s\n' % (arch, filename))

          self.image_data = data

      def set_up_files(self, name):

          datadir = os.path.join(os.path.dirname(__file__), 'data/maven', name)

          # load maven result data for our test build

          data['task_id'] = 9999

          taskdir = koji.pathinfo.task(data['task_id'])

          for subdir in data['files']:

              dst = os.path.join(taskdir, fn)

              shutil.copy(src, dst)

          self.maven_data = data

          files = [l.strip() for l in files]

          self.expected_files = files

  import unittest

  import mock

  import os

  import shutil

          for fn in self.files:

              path = os.path.join(uploaddir, fn)

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

                  fo.write('%s' % os.path.basename(fn))

          # generate pkglist file

          self.rpms = {}

          self.builds ={}

          self.key = '4c8da725'

              for nvr in nvrs:

                  binfo = koji.parse_NVR(nvr)

                  rpminfo = binfo.copy()

                  path = os.path.join(builddir, relpath)

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

                  basename = os.path.basename(path)

                      fo.write('%s' % basename)

                  f_pkglist.write(path)

                  f_pkglist.write('\n')

          for rpminfo in self.rpms.values():

              bnp = '%(name)s-%(version)s-%(release)s.%(arch)s.rpm' % rpminfo

              kojipkgs[bnp] = rpminfo

          self.files.append('kojipkgs')

          # write manifest

          # mocks

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

              basename = os.path.basename(path)

              if not os.path.exists(path):

                  raise Exception("Missing file: %s" % path)

              data.strip()

              self.assertEquals(data, basename)

                  dirpath = os.path.dirname(path)