repodir = pathinfo.repo(self.repo_info['id'], self.repo_info['tag_name'])

          repomdpath = os.path.join(repodir, self.br_arch, 'repodata', 'repomd.xml')

          opts['tempdir'] = self.options.workdir

          fo = koji.openRemoteFile(repomdpath, **opts)

          try:

          #srpm arg should be a path relative to <BASEDIR>/work

          self.logger.debug("Reading SRPM")

          relpath = "work/%s" % srpm

          opts['tempdir'] = self.workdir

          fo = koji.openRemoteFile(relpath, **opts)

          h = koji.get_rpm_header(fo)

                                 srcdir=scmsrcdir)

              kspath = os.path.join(scmsrcdir, os.path.basename(ksfile))

          else:

              tops['tempdir'] = self.workdir

              ks_src = koji.openRemoteFile(ksfile, **tops)

              kspath = os.path.join(self.workdir, os.path.basename(ksfile))

                                 srcdir=scmsrcdir)

              final_path = os.path.join(scmsrcdir, os.path.basename(filepath))

          else:

              tops['tempdir'] = self.workdir

              remote_fileobj = koji.openRemoteFile(filepath, **tops)

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

              # If the result is a Fault, then loads will raise it

              # This is normally what we want to happen

              result, method = xmlrpclib.loads(xml_result)

              if raise_fault:

                  raise

              # Note that you can't really return a fault over xmlrpc, except by

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

      koji.ensuredir(groupsdir)

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

      fo.write(comps)

      fo.close()

          top_relpath = koji.util.relpath(koji.pathinfo.topdir, archdir)

          top_link = os.path.join(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)

      mdfile.close()

      _generate_maven_metadata(destdir)

                      (img_path, img_size, old['filesize']))

      # old images always used sha256 hashes

      sha256sum = hashlib.sha256()

      while True:

          data = image_fo.read(1048576)

          sha256sum.update(data)

          filename = koji.fixEncoding(os.path.basename(filepath))

          archiveinfo['filename'] = filename

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

          m = md5_constructor()

          while True:

              contents = archivefp.read(8192)

              sumfile = mavenfile + ext

              if sumfile not in mavenfiles:

                  sum = sum_constr()

                  while True:

                      content = fobj.read(8192)

                      if not content:

                          break

                      sum.update(content)

                  fobj.close()

                  sumobj.write(sum.hexdigest())

                  sumobj.close()

      # - write to fs

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

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

      fo.write(sighdr)

      fo.close()

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

      sig_start, sigsize = koji.find_rpm_sighdr(fn)

      hdr_start = sig_start + sigsize

      hdrsize = koji.rpm_hdr_size(fn, hdr_start)

      outp = tempfile.TemporaryFile(mode='w+b')

      #before signature

      outp.write(inp.read(sig_start))

          koji.splice_rpm_sighdr(sighdr, rpm_path, temp)

          ts = rpm.TransactionSet()

          ts.setVSFlags(0)  #full verify

          hdr = ts.hdrFromFdno(fo.fileno())

          fo.close()

      except:

          else:

              os.unlink(signedpath)

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

      sighdr = fo.read()

      fo.close()

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

          fn = get_upload_path(path, name, create=True, volume=volume)

          try:

              st = os.lstat(fn)

              if e.errno == errno.ENOENT:

                  pass

              else:

                      # but we allow .log files to be uploaded multiple times to support

                      # realtime log-file viewing

                      raise koji.GenericError("file already exists: %s" % fn)

          # log_error("fd=%r" %fd)

          try:

              if offset == 0 or (offset == -1 and size == len(contents)):

          data = {}

          try:

              fd = os.open(fn, os.O_RDONLY)

              if e.errno == errno.ENOENT:

                  return None

              else:

          try:

              try:

                  fcntl.lockf(fd, fcntl.LOCK_SH|fcntl.LOCK_NB)

                  raise koji.LockError(e)

              st = os.fstat(fd)

              if not stat.S_ISREG(st.st_mode):

          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

          if isinstance(offset, str):

              offset = int(offset)

          if offset != None and offset > 0:

                              #handle older base64 encoded data

                              val = base64.decodestring(val)

                          data, method = xmlrpclib.loads(val)

                          data = fault

                      task[f] = data

              yield task

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

              try:

                  os.link(rpmpath, l_dst)

                  if ose.errno == 18:

                      shutil.copy2(

                          rpmpath, os.path.join(archdir, bnplet, bnp))

              # assuming login was asserted earlier

              u_fn = os.path.join(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))

                  fo.close()

      return os.path.join(udir, name)

      size = 0

      chksum = sum_cls()

      inf = environ['wsgi.input']

      try:

          try:

              fcntl.lockf(fd, fcntl.LOCK_EX|fcntl.LOCK_NB)

              raise koji.LockError(e)

          if offset == -1:

              offset = os.lseek(fd, 0, 2)

              # wrap response in a singleton tuple

              response = (response,)

              response = dumps(response, methodresponse=1, marshaller=Marshaller)

              self.traceback = True

              response = dumps(fault, marshaller=Marshaller)

          except:

          for call in calls:

              try:

                  result = self._dispatch(call['methodName'], call['params'])

                  results.append({'faultCode': fault.faultCode, 'faultString': fault.faultString})

              except:

                  # transform unknown exceptions into XML-RPC Faults

              flags = os.O_CREAT | os.O_WRONLY

              if append:

                  flags |= os.O_APPEND

              os.dup2(fd, 1)

              if logerror:

                  os.dup2(fd, 2)

              if not outfd:

                  try:

                  except IOError:

                      # will happen if the forked process has not created the logfile yet

                      continue

                      rootdir = "%s/root" % topdir

                      try:

                          st = os.lstat(rootdir)

                          if e.errno == errno.ENOENT:

                              rootdir = None

                          else:

                      #also remove the config

                      try:

                          os.unlink(data['cfg'])

                          self.logger.warn("%s: can't remove config: %s" % (desc, e))

                  elif age > 120:

                      if rootdir:

                          try:

                              flist = os.listdir(rootdir)

                              self.logger.warn("%s: can't list rootdir: %s" % (desc, e))

                              continue

                          if flist:

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

              if not os.path.isfile(fn):

                  continue

              id = None

              name = None

              for n in xrange(10):

          prefix = "Task %i (pid %i)" % (task_id, pid)

          try:

              (childpid, status) = os.waitpid(pid, os.WNOHANG)

              #check errno

              if e.errno != errno.ECHILD:

                  #should not happen

              try:

                  os.kill(pid, sig)

                  # process probably went away, we'll find out on the next iteration

                  self.logger.info('Error sending signal %i to %s (pid %i, taskID %i): %s' %

                                   (sig, execname, pid, task_id, e))

              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("RESPONSE: %r" % response)

              self.session.host.closeTask(handler.id, response)

              return

              response = koji.xmlrpcplus.dumps(fault)

              tb = ''.join(traceback.format_exception(*sys.exc_info())).replace(r"\n", "\n")

              self.logger.warn("FAULT:\n%s" % tb)

              try:

                  sent = con.send(data, flags)

                  if e[0] == 32:      # Broken Pipe

                      self.close()

                      sent = 0

                  return None

              except SSL.WantReadError:

                  time.sleep(0.2)

                  if e.args == (-1, 'Unexpected EOF'):

                      break

                  raise

                                  continue

                              try:

                                  self.session.getTaskResult(task)

                                  self.logger.info("task %s failed or was canceled" % task)

                                  failed = True

                                  break

              fsrc = six.moves.urllib.request.urlopen(url)

              if not os.path.exists(os.path.dirname(fn)):

                  os.makedirs(os.path.dirname(fn))

              shutil.copyfileobj(fsrc, fdst)

              fsrc.close()

              fdst.close()

              rmtree(tmpdir)

  def expand_rpm(filepath, tmpdir):

      rpm2cpio = subprocess.Popen(['/usr/bin/rpm2cpio', filepath],

                                  stdout=subprocess.PIPE,

                                  stdin=devnull, stderr=devnull,

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

              kwargs = json.load(fp)

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

          self.session.load_calls('build_notif_1')

          self.assertEqual(from_addr, "koji@example.com")

          self.assertEqual(recipients, ["user@example.com"])

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

              msg_expect = fp.read()

          self.assertEqual(message, msg_expect)

      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

                  dirpath = os.path.dirname(path)

              koji.ensuredir(dirpath)

              if path:

                      fo.write('TEST LOG FILE CONTENTS\n')

      def test_get_build_logs_basic(self):

          fullpath = '{0}/{1}'.format(work.return_value, reldir)

          os.makedirs(fullpath)

              f.write('1')

          with self.assertRaises(GenericError):

          """Download the file from buildreq, at filepath, into the basedir"""

          destpath = os.path.join(basedir, fileinfo['localpath'])

          ensuredir(os.path.dirname(destpath))

          offset = 0

          checksum = hashlib.md5()

          while True:

      """upload a single file to the vmd"""

      logger = logging.getLogger('koji.vm')

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

      offset = 0

      sum = hashlib.md5()

      while True:

      if opts.debug:

          level = logging.DEBUG

      logger.setLevel(level)

      handler = logging.StreamHandler(logfd)

      handler.setLevel(level)

      handler.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(name)s: %(message)s'))

              if not fd:

                  if os.path.isfile(log):

                      try:

                          logs[log] = (relpath, fd)

                      except:

                          log_local('Error opening %s' % log)