class ManagedRepo(object):

          self.manager = manager

          self.session = manager.session

          self.options = manager.options

          self.expire_ts = None

          if koji.REPO_STATES[self.state] in ['EXPIRED', 'DELETED', 'PROBLEM']:

              self.current = False

              # TODO use hub data to find the actual expiration time

          self.first_seen = time.time()

          if self.current:

                  tags[x['parent_id']] = 1

              self.taglist = to_list(tags.keys())

      @property

      def dist(self):

          # TODO: remove this indirection once we can rely on the hub to return

          age = time.time() - max(times)

          return age > timeout

          """Remove the repo from disk, if possible"""

          path = self.get_path()

          if not path:

              if e.errno == 2:

                  # No such file or directory, so the repo either never existed,

                  # or has already been deleted, so allow it to be marked deleted.

                  pass

              else:

                  return False

          else:

              times = [self.event_ts, mtime, self.expire_ts]

              times = [ts for ts in times if ts is not None]

              age = time.time() - max(times)

              if age < lifetime:

                  return False

          if self.state != koji.REPO_EXPIRED:

              raise koji.GenericError("Repo not expired")

          if self.session.repoDelete(self.repo_id) > 0:

              # cannot delete, we are referenced by a buildroot

              return False

          self.state = koji.REPO_DELETED

          if os.path.islink(path):

              # expected for repos on other volumes

              info = self.get_info()

              if not os.path.exists(path):

                  return False

              if not info or 'volume' not in info:

                  return False

              realpath = self.get_path(volume=info['volume'])

              if not os.path.exists(realpath):

                  return False

              if not os.path.samefile(path, realpath):

                  return False

              # ok, try to remove the symlink

              try:

                  os.unlink(path)

              except OSError:

          else:

          return True

      def ready(self):

              else:

                  self.logger.info('Found repo %s, state=%s'

                                   % (repo_id, koji.REPO_STATES[data['state']]))

                  self.repos[repo_id] = repo

              if not getTag(self.session, repo.tag_id) and not repo.expired():

                  self.logger.info('Tag %d for repo %d disappeared, expiring.', repo.tag_id, repo_id)

          finally:

              session.logout()

      def pruneLocalRepos(self):

          for volinfo in self.session.listVolumes():

              volumedir = pathinfo.volumedir(volinfo['name'])

                      time_expired = time.time() - tag['expire_ts']

                      f.write(fmt % (tag['taginfo']['name'], int(time_expired), int(tag['score'])))

      def checkTasks(self):

          """Check on newRepo tasks

          order = sorted(self.needed_tags.values(), key=lambda t: t['score'], reverse=True)

          for tag in order:

              if running_tasks >= self.options.max_repo_tasks:

                  self.logger.info("Maximum number of repo tasks reached")

                  return

              elif len(self.tasks) + len(self.other_tasks) >= self.options.repo_tasks_limit:

                  self.logger.info("Repo task limit reached")

                  return

              tagname = tag['taginfo']['name']

          if running_tasks_maven >= self.options.max_repo_tasks_maven:

              self.logger.info("Maximum number of maven repo tasks reached")

  def start_currency_checker(session, repomgr):

      subsession = session.subsession()

      return thread

  def main(options, session):

      repomgr = RepoManager(options, session)

      repomgr.readCurrentRepos()

      if options.check_external_repos:

          curr_ext_chk_thread = start_external_currency_checker(session, repomgr)

      regen_thread = start_regen_loop(session, repomgr)

      # TODO also move rmtree jobs to threads

      logger.info("Entering main loop")

      while True:

              if not regen_thread.is_alive():

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

                  regen_thread = start_regen_loop(session, repomgr)

          except KeyboardInterrupt:

              logger.warning("User exit")

              break