subject_handler = infer_subject_handler(mod)

      try:

          subjects = subject_handler(mod)

          mod.fail_json(msg=e.msg)

      mod.exit_json(msg="Successfuly acquired subjects", changed=True, subjects=subjects)

      try:

          kojidirective = KojiDirective()

          data = kojidirective.process(mod)

          mod.fail_json(msg=e)

      subjects = ' '.join(data['downloaded_rpms'])

  import ast

  from libtaskotron.ext.fedora.koji_utils import KojiClient

  from libtaskotron.ext.fedora import rpm_utils

  # along with Ansible.  If not, see <http://www.gnu.org/licenses/>.

  #

  import os

  import glob

  import sys

          f.write(text.encode('utf-8'))

          f.close()

      else:

  def list_modules(module_dir):

      if os.path.basename(fname)[-3:] != '.py':

          return

      doc, examples = get_docstring(fname, verbose=options.verbose)

              del doc['version_added']

      if 'parameters' in doc:

              all_keys.append(k)

          all_keys = sorted(all_keys)

          doc['option_keys'] = all_keys

      category_file_path = os.path.join(options.output_dir,

                                        "list_of_%s_modules.rst" % category)

      category_file = open(category_file_path, "w")

      category = category.replace("_", " ")

      category = category.title()

      ''' validate option parser options '''

      if not options.module_dir:

          sys.exit(1)

      if not os.path.exists(options.module_dir):

          sys.exit(1)

      if not options.template_dir:

          sys.exit(1)

          traceback.print_exc()  # temp

          if verbose is True:

              traceback.print_exc()

      return doc, plainexamples

  if __name__ == '__main__':

  #! /usr/bin/env python

  # encoding: utf-8

  import os

  import codecs

  import re

      meta = ['noarch', 'src']

      #: all known architectures

  def basearch(arch=None):

          try:

              builder, buildid = jobid.split('/')

              return (builder, buildid)

              log.debug(e)

              log.warning(

                  'Invalid jobid format detected, resetting to default '

  '''Helper tools for managing check status, outcome, and output.'''

  from __future__ import absolute_import

  import pprint

  import collections

  import yaml

  from . import python_utils

  from . import exceptions as exc

  from .logger import log

          self.output.append(message)

          if printout:

      @classmethod

              data['checkname'] = detail.checkname

          if detail._internal:

              data['_internal'] = detail._internal

              if key in RESERVED_KEYS:

                  log.warn("Reserved key '%s' found in keyvals. Ignoring for "

                           "export purposes.", key)

  from libtaskotron.config_defaults import (Config, ProductionConfig, TestingConfig, ProfileName,

                                            RuntaskModeName)

  from libtaskotron import file_utils

  CONF_DIRS = [ # local checkout dir first, then system wide dir

      os.path.abspath(os.path.dirname(libtaskotron.__file__) + '/../conf'),

      with open(filename, 'r') as datafile:

          try:

              return yaml.safe_load(datafile.read())

              raise exc.TaskotronConfigError(e)

  from libtaskotron.exceptions import TaskotronDirectiveError

  import libtaskotron.ext.fedora.bodhi_utils as bodhi

  from libtaskotron.ext.fedora.koji_utils import KojiClient

  from libtaskotron import config

  from libtaskotron import exceptions as exc

                  output_data['downloaded_files'].append(

                      file_utils.download(url, '.', localpath)

                  )

                  if e.errno == 404 and ignore_missing:

                      log.debug('File not found, ignoring: %s', url)

                  else:

  from libtaskotron.ext.fedora.koji_utils import KojiClient

  from libtaskotron.ext.fedora import rpm_utils

  from libtaskotron.logger import log

  from libtaskotron import file_utils

  DOCUMENTATION = """

              self.resultsdb.get_testcase(name)

              self._ensured_testcases.append(name)

              return

              if not e.message.startswith('Testcase not found'):

                  raise e

                  log.debug('Namespace %s found in the safe namespaces.', ns)

                  return

              if checkname.startswith(ns+'.'):

                  log.debug('Namespace %s found in the namespace whitelist.', ns)

                  ns_repos = repos

              gitconfig = configparser.ConfigParser()

              gitconfig.read(gitconfig_filename)

              task_repo_url = gitconfig['remote "origin"']['url']

              log.exception(e)

              raise TaskotronDirectiveError("Could not find task's git remote 'origin' url"

                                            "in %s" % gitconfig_filename)

                  log.debug('Result saved in ResultsDB:\n%s', pprint.pformat(result))

                  detail._internal['resultsdb_result_id'] = result['id']

                  log.error(e)

                  log.error("Failed to store to ResultsDB: `%s` `%s` `%s`",

                             detail.item, checkname, detail.outcome)

  directive_class = 'XunitDirective'

  class XunitDirective(BaseDirective):

      aggregations = ['none', 'allpass']

  from __future__ import absolute_import

  DOCUMENTATION = """

  module: yumrepoinfo_directive

  short_description: translate Koji tags into YUM repository URLs

  try:

      from libtaskotron.ext.disposable import vm

      raise exc.TaskotronImportError(e)

                      self.task_vm.ipaddr)

                  return self.task_vm.ipaddr

                  if retries <= 0:

                      raise exc.TaskotronMinionError('Disposable client failed '

                          'to boot: %s', e)

              subprocess.check_call(['ansible-playbook', '--syntax-check',

                  playbook])

              log.debug('Playbook is syntactically correct: %s', playbook)

              log.error('Syntax check failed for playbook %s: %s', playbook,

                        e)

              raise exc.TaskotronPlaybookError(e)

  from libtaskotron import exceptions as exc

  from libtaskotron.logger import log

  from libtaskotron import python_utils

  from . import rpm_utils

                  assert len(build[0]) <= 1, 'More than one build returned with latest=True'

                  nvrs.append(build[0][0]['nvr'])

          if sorted_nvrs:

              return sorted_nvrs[0]

  ''' Utility methods related to RPM '''

  from __future__ import absolute_import

  import re

  import hawkey

  import subprocess

      return int(rpmver1.evr_cmp(rpmver2, sack))

  def install(pkgs):

      '''Install packages from system repositories using DNF. Either root or sudo access required.

  '''A wrapper object for yumrepoinfo.conf to access its information easily'''

  from __future__ import absolute_import

  import os

  import socket

  from libtaskotron import config

  from libtaskotron.logger import log

  from libtaskotron import arch_utils

      return _yumrepoinfo[arch]

  class YumRepoInfo(object):

      '''This class is a wrapper for easily accessing repoinfo.conf file.'''

              [os.path.join(confdir, 'yumrepoinfo.conf')

               for confdir in config.CONF_DIRS])

          self.resolve_retry = resolve_retry

          if not self.filelist:

              # no data should be loaded

          '''

          try:

              return self.parser.get(reponame, key)

              raise exc.TaskotronConfigError("Can't retrieve key '%s' from repo "

                  "'%s': %s" % (key, reponame, e))

      try:

          os.makedirs(fullpath)

          assert os.path.isdir(fullpath)

          if e.errno == 17: # "[Errno 17] File exists"

              # if it is a directory everything is ok

              if os.path.isdir(fullpath):

          log.debug('Downloading%s: %s', ' (cached)' if cachedir else '', url)

          try:

              _download(url, dl_dest)

              log.exception('Download failed for: %s', url)

              # the file can be incomplete, remove

              if os.path.exists(dl_dest):

                  try:

                      os.remove(dl_dest)

                      log.exception('Could not delete incomplete file: %s', dl_dest)

              raise TaskotronRemoteError(e, errno=e.response.status_code)

  try:

      from libtaskotron.ext.fedora import rpm_utils

      raise exc.TaskotronImportError(e)

  ''' Utility methods related to an operating system '''

  from __future__ import absolute_import

  import os

  import subprocess

      if 'stdout' in kwargs:

          raise exc.TaskotronValueError('stdout parameter not allowed, it will be overridden')

      output = []

      for line in iter(proc.stdout.readline, ''):

          output.append(line)

      (stdoutdata, stderrdata) = proc.communicate()

  import libtaskotron.exceptions as exc

  def iterable(obj, item_type=None):

      '''Decide whether ``obj`` is an :class:`~collections.Iterable` (you can

          cmdline.extend(segment)

      return cmdline

  from libtaskotron.ext.fedora import koji_utils

  from libtaskotron import file_utils

  class TestKojiClient():

  from libtaskotron.ext.fedora import yumrepoinfo

  from libtaskotron import exceptions as exc

  @pytest.mark.usefixtures('setup')

  import pytest

  import mock

  from libtaskotron.directives import yumrepoinfo_directive

  from libtaskotron.exceptions import TaskotronDirectiveError

  from libtaskotron.ext.fedora import yumrepoinfo

  class TestYumrepoinfoDirective(object):

          yumrepoinfo object instead of falling back to the default system arch"""

          ref_arch = 'i386'

          repoinfo = yumrepoinfo.YumRepoInfo(filelist=[], arch='x86_64')

          stub_getrepoinfo = mock.MagicMock(return_value=repoinfo)

          monkeypatch.setattr(yumrepoinfo, 'get_yumrepoinfo', stub_getrepoinfo)

  '''Unit tests for libtaskotron/config.py'''

  import os

  import pytest

  import mock

  from libtaskotron import config

  from libtaskotron import exceptions as exc

  @pytest.mark.usefixtures('setup')

  class TestConfig(object):

          '''By default we should have a testing profile'''

          assert os.getenv(config.PROFILE_VAR) == config.ProfileName.TESTING

          conf = config.get_config()

          assert conf.profile == config.ProfileName.TESTING

          assert isinstance(conf, config.TestingConfig)

      def test_load_defaults(self):

          '''Test _load_defaults() function'''

          for attr, value in vars(config.ProfileName).items():

              if attr.startswith('_'):

                  continue

              conf = config._load_defaults(value)

      def test_load_file_empty(self):

          '''Test _load_file() function with empty file'''

          conf_object = config._load_file(contents)

          assert conf_object == {}

      def test_load_file_commented(self):

          '''Test _load_file() function with fully commented out file'''

  # first commented line

  # second: line

  # last line

      def test_load_file_options(self):

          '''Test _load_file() function with some options present'''

  option1: value1

  # option2: value2

  option3: 15

      def test_load_file_invalid_syntax(self):

          '''Test _load_file() function with invalid syntax'''

          with pytest.raises(exc.TaskotronConfigError):

              config._load_file(contents)

          with pytest.raises(exc.TaskotronConfigError):

              config._load_file(contents)

      def test_load_file_invalid_type(self):

          '''Test _load_file() function with invalid option type'''

          # tmpdir is string, with string it should pass

          config._load_file(contents)

          # but with anything else, it should fail

          with pytest.raises(exc.TaskotronConfigError):

              config._load_file(contents)

      def test_merge_config(self):

          file_data = '%'

          mocked_open = mock.mock_open(read_data=file_data)

              with pytest.raises(exc.TaskotronConfigError):

                  config.parse_yaml_from_file('mocked_filename')

          file_data = ':'

          mocked_open = mock.mock_open(read_data=file_data)

              with pytest.raises(exc.TaskotronConfigError):

                  config.parse_yaml_from_file('mocked_filename')

  from libtaskotron import file_utils

  from libtaskotron import arch_utils

  # http://stackoverflow.com/questions/3190706/nonlocal-keyword-in-python-2-x

  def create_multicall(first, second):

  from libtaskotron import python_utils

  import libtaskotron.exceptions as exc

  class TestCollectionOf:

      def test_not_iterable(self):

          assert not python_utils.iterable('a')

          assert not python_utils.iterable(u'a')

          assert not python_utils.iterable(3)

          assert not python_utils.iterable(3.14)

          assert not python_utils.iterable(None)

          assert python_utils.iterable(['a', 'b'], str)

          assert python_utils.iterable(['a', 'b'], basestring)

          assert python_utils.iterable([[], []], list)

          # empty classes

  from libtaskotron.check import CheckDetail, export_YAML, import_YAML

  import mock

  import os

  import argparse

  OUTPUT = ""

  FILE = """results:

          stub_file = mock.MagicMock()

          stub_file.write = save_output

              taskotron_result.main()

          assert OUTPUT == export_YAML(CheckDetail(**vars(test_args)))

          monkeypatch.setattr(os.path, 'isfile', mock.MagicMock(return_value=True))

              taskotron_result.main()

          assert OUTPUT == export_YAML(import_YAML(FILE)+[CheckDetail(**vars(test_args))])

          stub_file = mock.MagicMock()

          stub_file.write = save_output

              taskotron_result.main()

          assert OUTPUT == export_YAML(CheckDetail(**vars(test_args)))

  '''Unit tests for libtaskotron/yumrepoinfo.py'''

  import pytest

  import mock

  from libtaskotron.ext.fedora import yumrepoinfo

  from libtaskotron import exceptions as exc

  [DEFAULT]

  baseurl = http://download.fedoraproject.org/pub/fedora/linux

  baseurl_altarch = http://download.fedoraproject.org/pub/fedora-secondary

          monkeypatch.setattr(yumrepoinfo.YumRepoInfo, '_switch_to_mirror', mock.Mock())

          # create YumRepoInfo initialized with TEST_CONF

          self.repoinfo = yumrepoinfo.YumRepoInfo(filelist=[])

      @pytest.fixture

      def disable_disk_loading(self, monkeypatch):

          '''Patch ConfigParser not to load from disk.'''

          # instead of reading from disk, just return the input parameter

                              lambda self, cfg: cfg)

      @pytest.fixture

      def test_init_arch(self, disable_disk_loading):

          '''Test YumRepoInfo(arch=)'''

          repoinfo = yumrepoinfo.YumRepoInfo(arch='x86_64', filelist=[])

          assert '/x86_64/' in repoinfo.get('rawhide', 'url')

      def test_init_basearch(self, disable_disk_loading):

          '''i686 should be converted to i386'''

          repoinfo = yumrepoinfo.YumRepoInfo(arch='i686', filelist=[])

          assert '/i386/' in repoinfo.get('rawhide', 'url')

      def test_init_empty_filelist(self, monkeypatch):

          # make sure the disk is not read

          def _raise_alarm(x):

              assert False, 'This must not be called'

          repoinfo = yumrepoinfo.YumRepoInfo(filelist=[])

          assert not repoinfo.repos()