:maxdepth: 2

      HOWTO

      defining_hub_policies

      external_repo_server_bootstrap

      image_build

  def writeInheritanceData(tag_id, changes, clear=False):

      """Add or change inheritance data for a tag"""

      _writeInheritanceData(tag_id, changes, clear)

  def grplist_add(taginfo, grpinfo, block=False, force=False, **opts):

      """Add to (or update) group list for tag"""

      #only admins....

      _grplist_add(taginfo, grpinfo, block, force, **opts)

      Most of the time you really want to use the block or unblock functions

      """

      #only admins....

      _grplist_remove(taginfo, grpinfo, force)

      Otherwise, raise an error

      """

      # only admins...

      _grplist_unblock(taginfo, grpinfo)

  def grp_pkg_add(taginfo, grpinfo, pkg_name, block=False, force=False, **opts):

      """Add package to group for tag"""

      #only admins....

      _grp_pkg_add(taginfo, grpinfo, pkg_name, block, force, **opts)

      Most of the time you really want to use the block or unblock functions

      """

      #only admins....

      _grp_pkg_remove(taginfo, grpinfo, pkg_name, force)

      Otherwise, raise an error

      """

      # only admins...

      _grp_pkg_unblock(taginfo, grpinfo, pkg_name)

  def grp_req_add(taginfo, grpinfo, reqinfo, block=False, force=False, **opts):

      """Add group requirement to group for tag"""

      #only admins....

      _grp_req_add(taginfo, grpinfo, reqinfo, block, force, **opts)

      Most of the time you really want to use the block or unblock functions

      """

      #only admins....

      _grp_req_remove(taginfo, grpinfo, reqinfo, force)

      Otherwise, raise an error

      """

      # only admins...

      _grp_req_unblock(taginfo, grpinfo, reqinfo)

          return [x for x in groups if not x['blocked']]

  def set_host_enabled(hostname, enabled=True):

      host = get_host(hostname)

      if not host:

          raise koji.GenericError('host does not exist: %s' % hostname)

      Channel must already exist unless create option is specified

      """

      host = get_host(hostname)

      if host == None:

          raise koji.GenericError('host does not exist: %s' % hostname)

      insert.execute()

  def remove_host_from_channel(hostname, channel_name):

      host = get_host(hostname)

      if host == None:

          raise koji.GenericError('host does not exist: %s' % hostname)

  def create_build_target(name, build_tag, dest_tag):

      """Create a new build target"""

      return _create_build_target(name, build_tag, dest_tag)

  def edit_build_target(buildTargetInfo, name, build_tag, dest_tag):

      """Set the build_tag and dest_tag of an existing build_target to new values"""

      _edit_build_target(buildTargetInfo, name, build_tag, dest_tag)

  def delete_build_target(buildTargetInfo):

      """Delete the build target with the given name.  If no build target

      exists, raise a GenericError."""

      _delete_build_target(buildTargetInfo)

  def create_tag(name, parent=None, arches=None, perm=None, locked=False, maven_support=False, maven_include_all=False, extra=None):

      """Create a new tag"""

      return _create_tag(name, parent, arches, perm, locked, maven_support, maven_include_all, extra)

      :param list remove_extra: remove extra tag parameters.

      """

      _edit_tag(tagInfo, **kwargs)

  def delete_tag(tagInfo):

      """Delete the specified tag."""

      _delete_tag(tagInfo)

  def add_external_repo_to_tag(tag_info, repo_info, priority, merge_mode='koji'):

      """Add an external repo to a tag"""

      if merge_mode not in koji.REPO_MERGE_MODES:

          raise koji.GenericError('Invalid merge mode: %s' % merge_mode)

  def remove_external_repo_from_tag(tag_info, repo_info):

      """Remove an external repo from a tag"""

      tag = get_tag(tag_info, strict=True)

      tag_id = tag['id']

      """Edit a tag<->external repo association

      This allows you to update the priority without removing/adding the repo."""

      tag = get_tag(tag_info, strict=True)

      tag_id = tag['id']

      Returns True if changes are made to the database, False otherwise.

      """

      host = get_host(hostInfo, strict=True)

      '''Contains functions that are made available via XMLRPC'''

      def restartHosts(self, priority=5, options=None):

          if options is None:

              args = []

          else:

          """

          # verify existence of tag and/or convert name to id

          tag = get_tag_id(tag, strict=True)

          return writeInheritanceData(tag, data, clear=clear)

      def getFullInheritance(self, tag, event=None, reverse=False, stops=None, jumps=None):

          If krb_principal is not given then that field will be generated

          from the HostPrincipalFormat setting (if available).

          """

          # validate arches

          arches = " ".join(arches)

          arches = koji.parse_arches(arches, strict=True)

          r = self.exports.addHost('hostname', ['i386', 'x86_64'])

          self.assertEqual(r, 12)

          kojihub.get_host.assert_called_once_with('hostname')

          self.context.session.createUser.assert_called_once_with('hostname',

                  usertype=koji.USERTYPES['HOST'], krb_principal='-hostname-')

          with self.assertRaises(koji.GenericError):

              kojihub.delete_tag('badtag')

          self.assertEqual(self.updates, [])

      def test_good_tag(self):

          self.get_tag.return_value = {'id': 'TAGID'}

              self.assertEqual(u.values, {'value': 'TAGID'})

              self.assertEqual(u.rawdata, {'active': 'NULL'})

              self.assertEqual(u.data, data)

          kojihub.grplist_add(tag, group)

          # what was called

          self.get_tag.assert_called_once_with(tag, strict=True)

          self.lookup_group.assert_called_once_with(group, create=True)

          self.get_tag_groups.assert_called_with('tag_id', inherit=True,

          self.context.session.assertPerm.side_effect = koji.GenericError

          with self.assertRaises(koji.GenericError):

              kojihub.grplist_add('tag', 'group')

          self.assertEqual(len(self.inserts), 0)

          self.assertEqual(len(self.updates), 0)

          self.get_tag.side_effect = koji.GenericError

          with self.assertRaises(koji.GenericError):

              kojihub.grplist_add('tag', 'group')

          self.assertEqual(len(self.inserts), 0)

          self.assertEqual(len(self.updates), 0)

          kojihub.grplist_block(tag, group)

          # what was called

          self.get_tag.assert_called_once_with(tag, strict=True)

          self.lookup_group.assert_called_once_with(group, create=True)

          self.get_tag_groups.assert_called_with('tag_id', inherit=True,

          kojihub.grplist_remove(tag, group)

          # what was called

          self.get_tag.assert_called_once_with(tag, strict=True)

          self.lookup_group.assert_called_once_with(group, strict=True)

              kojihub.grplist_unblock(tag, group)

          # what was called

          self.lookup_tag.assert_called_once_with(tag, strict=True)

          self.lookup_group.assert_called_once_with(group, strict=True)