Methods = ['newRepo']

      _taskWeight = 0.1

          tinfo = self.session.getTag(tag, strict=True, event=event)

          kwargs = {}

          if event is not None:

              kwargs['event'] = event

          if src:

              kwargs['with_src'] = True

          if debuginfo:

              kwargs['with_debuginfo'] = True

          repo_id, event_id = self.session.host.repoInit(tinfo['id'], **kwargs)

      parser.add_option("--target", action="store_true", help=_("Interpret the argument as a build target name"))

      parser.add_option("--nowait", action="store_true", help=_("Don't wait on for regen to finish"))

      parser.add_option("--debuginfo", action="store_true", help=_("Include debuginfo rpms in repo"))

      (suboptions, args) = parser.parse_args(args)

      if len(args) == 0:

          parser.error(_("A tag name must be specified"))

          repo_opts['debuginfo'] = True

      if suboptions.source:

          repo_opts['src'] = True

      task_id = session.newRepo(tag, **repo_opts)

      print("Regenerating repo for tag: %s" % tag)

      print("Created task: %d" % task_id)

                      yield archive

      return _iter_archives()

      """Create a new repo entry in the INIT state, return full repo data

      Returns a dictionary containing

      state = koji.REPO_INIT

      tinfo = get_tag(tag, strict=True, event=event)

      koji.plugin.run_callbacks('preRepoInit', tag=tinfo, with_src=with_src, with_debuginfo=with_debuginfo,

      tag_id = tinfo['id']

      repo_arches = {}

      if tinfo['arches']:

          for arch in tinfo['arches'].split():

              arch = koji.canonArch(arch)

              if with_src:

                  for repoarch in repo_arches:

                      pkglist[repoarch].write(relpath)

          elif arch == 'noarch':

              for repoarch in repo_arches:

                  pkglist[repoarch].write(relpath)

              _write_maven_repo_metadata(artifact_dir, artifacts)

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

      return [repo_id, event_id]

  def _write_maven_repo_metadata(destdir, artifacts):

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

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

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

      if not event:

          event = get_event()

      repo_id = nextval('repo_id_seq')

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

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

              dist=True, keys=keys, arches=arches, task_opts=task_opts,

      return repo_id, event

          task_opts['event'] = event_id

          return make_task('distRepo', [tag, repo_id, keys, task_opts], priority=15, channel='createrepo')

          """Create a newRepo task. returns task id"""

          if context.session.hasPerm('regen-repo'):

              pass

              opts['event'] = event

          if src:

              opts['src'] = True

          if debuginfo:

              opts['debuginfo'] = True

          args = koji.encode_args(tag, **opts)

          return br.updateArchiveList(archives, project)

          """Initialize a new repo for tag"""

          host = Host()

          host.verify()

      def repoAddRPM(self, repo_id, path):

          """Add an uploaded rpm to a repo"""

          [['builds', 'target', 'opts'], None, None, (None,)],

      ],

      'newRepo' : [

      ],

      'createImage' : [

          [['name', 'version', 'release', 'arch', 'target_info', 'build_tag', 'repo_info', 'inst_tree', 'opts'], None, None, (None,)],

  (Specify the --help global option for a list of other help options)

  Options:

  """ % self.progname)

          debuginfo_pat = self.options.debuginfo_tags.split()

          src_pat = self.options.source_tags.split()

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

          for tag in order:

              if running_tasks >= self.options.max_repo_tasks:

                  taskopts['debuginfo'] = True

              if koji.util.multi_fnmatch(tagname, src_pat):

                  taskopts['src'] = True

              maven = tag['taginfo']['maven_support']

              if maven:

                  if running_tasks_maven >= self.options.max_repo_tasks_maven:

      defaults = {'with_src': False,

                  'debuginfo_tags': '',

                  'source_tags': '',

                  'ignore_tags': '',

                  'verbose': False,

                  'debug': False,

                      'recent_tasks_lifetime')

          str_opts = ('topdir', 'server', 'user', 'password', 'logfile', 'principal', 'keytab', 'krbservice',

                      'cert', 'ca', 'serverca', 'debuginfo_tags',

          bool_opts = ('with_src','verbose','debug','ignore_stray_repos', 'offline_retry',

                       'krb_rdns', 'krb_canon_host', 'no_ssl_verify')

          for name in config.options(section):