raise SystemExit

      def restart(*args):

          tm.restart_pending = True

      signal.signal(signal.SIGTERM, shutdown)

      signal.signal(signal.SIGUSR1, restart)

              tm.updateTasks()

              taken = tm.getNextTask()

          except (SystemExit, ServerExit, KeyboardInterrupt):

              break

          except ServerRestart:

              os.execv(sys.argv[0], sys.argv)

          except koji.AuthExpired:

              logger.error('Session expired')

                  # from getting overloaded.

                  time.sleep(options.sleeptime)

          except (SystemExit, KeyboardInterrupt):

              break

      tm.shutdown()

      session.logout()

      sys.exit(0)

          if not avg:

              return

          if avg < 0:

              return

          # increase the task weight by 0.75 for every hour of build duration

          adj = avg / 4800.0

              oldpath = self.pathinfo.repo(oldrepo['id'], oldrepo['tag_name'])

              olddatadir = '%s/%s/repodata' % (oldpath, arch)

              if not os.path.isdir(olddatadir):

              else:

                  shutil.copytree(olddatadir, self.datadir)

                  oldorigins = os.path.join(self.datadir, 'pkgorigins.gz')

              cmd.extend(['-g', groupdata])

          if pkglist and oldrepodata and self.options.createrepo_update:

              if not os.path.isdir(oldrepodata):

              else:

                  datadir = os.path.join(repodir, 'repodata')

                  shutil.copytree(oldrepodata, datadir)

      # basic checks

      volname = binfo.get('volume_name')

      if volname is None:

          return

      if volname == 'DEFAULT':

          # nothing to do

          logger.error('Invalid default volume: %s', default)

      if strict:

          raise koji.GenericError('No volume policy match')

      return None

          sinfo = dict(zip(['session-id', 'session-key'], sinfo_str.split()))

          if not sinfo:

              return False

          self.setSession(sinfo)

          for allowed_scm in allowed.split():

              scm_tuple = allowed_scm.split(':')

              if len(scm_tuple) < 2:

                  continue

              host_pat = scm_tuple[0]

              repo_pat = scm_tuple[1]

              if task_id is None:

                  # not associated with a task

                  # this makes no sense now, but may in the future

                  self.session.host.setBuildRootState(id, st_expired)

              elif task_id not in self.tasks:

                  # task not running - expire the buildroot

                  data = local_br[id]

                  br = missed_br.get(id)

                  if not br:

                      continue

                  desc = "%(id)i/%(tag_name)s/%(arch)s" % br

                  if not br['retire_ts']:

                      continue

                  age = time.time() - br['retire_ts']

                  self.logger.debug("Expired/stray buildroot: %s" % desc)

                  if br and br['task_id']:

                      task = tasks.get(br['task_id'])

                      if not task:

                          continue

                      if task['state'] == koji.TASK_STATES['FAILED'] and \

                              age < self.options.failed_buildroot_lifetime:

                          if e.errno == errno.ENOENT:

                              rootdir = None

                          else:

                              continue

                      else:

                          age = min(age, time.time() - st.st_mtime)

                      try:

                          os.unlink(data['cfg'])

                      except OSError as e:

                  elif age > 120:

                      if rootdir:

                          try:

                              flist = os.listdir(rootdir)

                          except OSError as e:

                              continue

                          if flist:

                              self.logger.info("%s: clearing rootdir" % desc)

              # note: tasks are in priority order

              self.logger.debug("task: %r" % task)

              if task['method'] not in self.handlers:

                  continue

              if task['id'] in self.tasks:

                  # we were running this task, but it apparently has been

                  return True

              if t >= timeout:

                  return False

              try:

          if availableMB < self.options.minspace:

              self.status = "Insufficient disk space at %s: %i MB, %i MB required" % \

                            (br_path, availableMB, self.options.minspace)

              return False

          return True

              raise koji.GenericError("No handler found for method '%s'" % method)

          task_info = self.session.getTaskInfo(task['id'], request=True)

          if task_info.get('request') is None:

              return False

          params = task_info['request']

          handler = handlerClass(task_info['id'], method, params, self.session, self.options)

                  raise

              except Exception:

                  valid_host = False

              if not valid_host:

                  self.logger.info(

                      'Skipping task %s (%s) due to host check', task['id'], task['method'])

                  return False

          data = self.session.host.openTask(task['id'])

          if data is None:

              return False

          task_id = data['id']

          self.tasks[task_id] = data

          except koji.ActionNotAllowed:

              info2 = self.session.getTaskInfo(task['id'])

              if info2['host_id'] != self.host_id:

                  return False

              state = koji.TASK_STATES[info2['state']]

              if state != 'OPEN':

                  return False

              # otherwise...

              raise

          except koji.xmlrpcplus.Fault as fault:

              response = koji.xmlrpcplus.dumps(fault)

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

          except (SystemExit, koji.tasks.ServerExit, KeyboardInterrupt):

              # we do not trap these

              raise

              return

          except Exception:

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

              # report exception back to server

              e_class, e = sys.exc_info()[:2]

              faultCode = getattr(e_class, 'faultCode', 1)

          except Exception:

              msg = 'Error running %s callback from %s' % (cbtype, func.__module__)

              if getattr(func, 'failure_is_an_option', False):

              else:

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

                  raise koji.CallbackError('%s:\n%s' % (msg, tb))

              if strict:

                  raise

              else:

                  return 1

          return 0

      if not os.path.exists(path):

      try:

          koji.util.rmtree(path)

      except Exception:

          if strict:

              raise

          return 1

              continue

          if len(limits) == 1:

              limits.append(orig[1])

          try:

              resource.setrlimit(rcode, tuple(limits))

          except ValueError as e:

                  failed.append("%s: %s" % (dir, output))

          if failed:

              msg = "Unable to unmount: %s" % ', '.join(failed)

              if fatal:

                  raise koji.GenericError(msg)

          else:

          del self.buildinfo['volume_name']

          with mock.patch('kojihub.logger') as logger:

              kojihub.ensure_volume_symlink(self.buildinfo)

      def test_volume_symlink_create(self):

          basedir = self.pathinfo.build(self.buildinfo)  # default volume

          self.assertEqual(len(self.callbacks), 1)

          self.assertEqual(self.callbacks[0], [cbtype, args, kwargs])

          getLogger.assert_called_once()

      def test_datetime_callback(self):

          dt1 = datetime.datetime.now()

              return None

          fn = '%s/repo.json' % path

          if not os.path.exists(fn):

              return None

          with open(fn, 'r') as fp:

              return json.load(fp)

          if not tag_info:

              tag_info = getTag(self.session, self.tag_id, self.event_id)

          if not tag_info:

              return None

          tag_name = tag_info['name']

          if self.dist:

              self.logger.debug("%s doesn't exist, skipping", topdir)

              return

          if not os.path.isdir(topdir):

              return

          self.logger.debug("Scanning %s for repos", topdir)

          self.logger.debug('max age allowed: %s seconds', max_age)

                                  self.rmtree(repodir)

                      continue

                  if rinfo['tag_name'] != tag:

                          "Tag name mismatch (rename?): %s vs %s", tag, rinfo['tag_name'])

                      continue

                  if rinfo['state'] in (koji.REPO_DELETED, koji.REPO_PROBLEM):

                  logger.error("Regeneration thread died. Restarting it.")

                  regen_thread = start_regen_loop(session, repomgr)

          except KeyboardInterrupt:

              break

          except koji.AuthExpired:

              break

          except SystemExit:

              break

          except Exception:

              # log the exception and continue

          try:

              time.sleep(options.sleeptime)

          except KeyboardInterrupt:

              break

      try:

          repomgr.checkQueue()

  def libvirt_callback(ignore, err):

      if err[3] != libvirt.VIR_ERR_ERROR:

          # Don't log libvirt errors: global error handler will do that

  libvirt.registerErrorHandler(f=libvirt_callback, ctx=None)

          raise SystemExit

      def restart(*args):

          tm.restart_pending = True

      signal.signal(signal.SIGTERM, shutdown)

      signal.signal(signal.SIGUSR1, restart)

              taken = tm.getNextTask()

              tm.cleanupExpiredVMs()

          except (SystemExit, ServerExit, KeyboardInterrupt):

              break

          except ServerRestart:

              os.execv(sys.argv[0], sys.argv)

          except koji.AuthExpired:

              logger.error('Session expired')

                  # from getting overloaded.

                  time.sleep(options.sleeptime)

          except (SystemExit, KeyboardInterrupt):

              break

      tm.shutdown()

      session.logout()

      sys.exit(0)

              time.sleep(15)

              info = vm.info()

              if info[0] in (libvirt.VIR_DOMAIN_CRASHED, libvirt.VIR_DOMAIN_SHUTOFF):

                  self.server.server_close()

                  raise koji.BuildError('VM %s crashed' % clone_name)

              if self.success is None:

          if availableMB < self.options.minspace:

              self.status = 'Insufficient disk space: %i MB, %i MB required' % \

                            (availableMB, self.options.minspace)

              return False

          return True

          if avail_mem < min_mem:

              self.status = 'Insufficient memory: %sk allocated, %sk available, %sk required' % \

                            (vm_mem, avail_mem, min_mem)

              return False

          return True

              vm = self.libvirt_conn.lookupByName(vm_name)

          except libvirt.libvirtError:

              # if we can't find the VM by name, it has probably been cleaned up manually

              return True

          info = vm.info()

          if info[0] not in (libvirt.VIR_DOMAIN_SHUTOFF, libvirt.VIR_DOMAIN_CRASHED):

      value = cookies['user'].value

      parts = value.split(":", 1)

      if len(parts) != 2:

          return None

      sig, value = parts

      if not options['Secret'].value:

          digest_string = digest_string.encode('utf-8')

      shasum = hashlib.sha1(digest_string)

      if shasum.hexdigest() != sig:

          return None

      parts = value.split(":", 1)

      if len(parts) != 2:

          # no embedded timestamp

          return None

      user, timestamp = parts

      try:

          timestamp = float(timestamp)

      except ValueError:

          return None

      if (time.time() - timestamp) > (int(options['LoginTimeout']) * 60 * 60):

          authlogger.info('expired user cookie: %s', value)