from fnmatch import fnmatch

  from gzip import GzipFile

  from optparse import OptionParser, SUPPRESS_HELP

  from yum import repoMDObject

  #imports for LiveCD, LiveMedia, and Appliance handler

                  bld_info = self.initImageBuild(name, version, release,

                      target_info, opts)

              subtasks = {}

              for arch in arches:

                  subtasks[arch] = self.subtask('createLiveMedia',

                      [name, version, release, arch, target_info, build_tag,

                          repo_info, ksfile, opts],

                      label='livemedia %s' % arch, arch=arch)

              self.logger.debug("Got image subtasks: %r", subtasks)

              self.logger.debug("Waiting on livemedia subtasks...")

              self.logger.debug('subtask results: %r', results)

              # wrap each image an RPM if needed

              spec_url = opts.get('specfile')

                      subtask_id = subtasks[arch]

                      result = results[subtask_id]

                      tinfo = self.session.getTaskInfo(subtask_id)

                      arglist = [spec_url, target_info, bld_info, tinfo,

                                  {'repo_id': repo_info['id']}]

                      wrapper_tasks[arch] = self.subtask('wrapperRPM', arglist,

                  # add wrapper rpm results into main results

                  for arch in arches:

                      result = results[subtasks[arch]]

                      result2 = results2[wrapper_tasks[arch]]

                      result['rpmresults'] = result2

          help=_("SCM URL to spec file fragment to use to generate wrapper RPMs"))

      parser.add_option("--skip-tag", action="store_true",

                        help=_("Do not attempt to tag package"))

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

      # Make sure the target and kickstart is specified.

      if len(args) != 5:

                         " a kickstart file."))

          assert False  # pragma: no cover

      _build_image(options, task_options, session, args, 'livemedia')

          help=_("Create a scratch image"))

      parser.add_option("--skip-tag", action="store_true",

                        help=_("Do not attempt to tag package"))

      parser.add_option("--specfile", metavar="URL",

          help=_("SCM URL to spec file fragment to use to generate wrapper RPMs"))

      parser.add_option("--wait", action="store_true",

          ksfile = os.path.join(serverdir, os.path.basename(ksfile))

          print

      passthru_opts = [

          ]

      for opt in passthru_opts:

          val = getattr(task_opts, opt, None)

          if val is not None:

          params, method = xmlrpclib.loads(xml_request)

          return params

          query = """SELECT state,result FROM task WHERE id = %(id)i"""

          r = _fetchSingle(query, vars(self))

          if not r:

              raise koji.GenericError, "Task %i is canceled" % self.id

          elif koji.TASK_STATES[state] not in ['CLOSED', 'FAILED']:

              raise koji.GenericError, "Task %i is not finished" % self.id

          if xml_result.find('<?xml', 0, 10) == -1:

              #handle older base64 encoded data

              xml_result = base64.decodestring(xml_result)

          return result[0]

      def getInfo(self, strict=True, request=False):

          task = Task(taskId)

          return task.getRequest()

          task = Task(taskId)

      def getTaskInfo(self, task_id, request=False):

          """Get information about a task"""

                  c.execute(q, locals())

          return [finished, unfinished]

          # If we're getting results, we're done waiting

          self.taskUnwait(parent)

          c = context.cnx.cursor()

              # Query all subtasks

              tasks = []

              c.execute(q, locals())

                  if state == canceled:

                      raise koji.GenericError, "Subtask canceled"

                  elif state in (closed, failed):

          # Would use a dict, but xmlrpc requires the keys to be strings

          results = []

          return results

      def getHostTasks(self):

          host.verify()

          return host.taskWait(parent)

          host = Host()

          host.verify()

      def subtask(self, method, arglist, parent, **opts):

          host = Host()

          task.assertHost(host.id)

          logger.debug('scratch image results: %s' % results)

          for sub_results in results.values():

              workdir = koji.pathinfo.task(sub_results['task_id'])

              scratchdir = koji.pathinfo.scratch()

              username = get_user(task.getOwner())['name']

          moving the image to its final location.

          """

          for sub_results in results.values():

              importImageInternal(task_id, build_id, sub_results)

              if sub_results.has_key('rpmresults'):

                  rpm_results = sub_results['rpmresults']

          safe_rmtree(self.workdir, unmount=False, strict=True)

          #os.spawnvp(os.P_WAIT, 'rm', ['rm', '-rf', self.workdir])

          """Wait on subtasks

          subtasks is a list of integers (or an integer). If more than one subtask

          is specified, then the default behavior is to return when any of those

          tasks complete. However, if all is set to True, then it waits for all of

          special values:

              subtasks = None     specify all subtasks

              the database and will send the subprocess corresponding to the

              subtask a SIGUSR2 to wake it up when subtasks complete.

          """

          if isinstance(subtasks, int):

              # allow single integer w/o enclosing list

              subtasks = [subtasks]

                      if failany:

                          failed = False

                          for task in finished:

                              try:

                                  self.session.getTaskResult(task)

                              except (koji.GenericError, xmlrpclib.Fault), task_error:

              self.logger.debug("...waking up")

          self.logger.debug("Finished waiting")

          if all:

      def getUploadDir(self):

          return koji.pathinfo.taskrelpath(self.id)

              os.spawnvp(os.P_NOWAIT, 'sleep', ['sleep', str(m)])

  class WaitTestTask(BaseTaskHandler):

      Methods = ['waittest']

      _taskWeight = 0.1

      def handler(self, count, seconds=10):

          tasks = []

          for i in xrange(count):

              tasks.append(task_id)

          self.logger.info(pprint.pformat(results))

  import random

  from unittest import TestCase

  from mock import patch, Mock, call

  import koji

  def get_fake_mounts_file():

      """ Returns contents of /prc/mounts in a file-like object

          obj.session.host.taskWaitResults.return_value = taskWaitResults

          self.assertEquals(obj.wait([1551234, 1591234]), dict(taskWaitResults))

          obj.session.host.taskSetWait.assert_called_once_with(12345678, [1551234, 1591234])

      def test_BaseTaskHandler_wait_some_not_done(self):

          """ Tests that the wait function returns the one finished subtask results of

          obj.session.host.taskWaitResults.return_value = taskWaitResults

          self.assertEquals(obj.wait([1551234, 1591234]), dict(taskWaitResults))

          obj.session.host.taskSetWait.assert_called_once_with(12345678, [1551234, 1591234])

      @patch('signal.pause', return_value=None)

      def test_BaseTaskHandler_wait_some_not_done_all_set(self, mock_signal_pause):

          obj.session.host.taskSetWait.assert_called_once_with(12345678, [1551234, 1591234])

          obj.session.host.taskWait.assert_has_calls([call(12345678), call(12345678)])

          mock_signal_pause.assert_called_once_with()

      def test_BaseTaskHandler_wait_some_not_done_all_set_failany_set_failed_task(self):

          """ Tests that the wait function raises an exception when one of the subtask fails when the failany flag is set

          obj.session = Mock()

          obj.session.host.taskSetWait.return_value = None

          obj.session.host.taskWait.side_effect = [[[1551234], [1591234]], [[1551234, 1591234], []]]

          try:

              obj.wait([1551234, 1591234], all=True, failany=True)

              raise Exception('A GeneralError was not raised.')

              self.assertEquals(e.message, 'Uh oh, we\'ve got a problem here!')

              obj.session.host.taskSetWait.assert_called_once_with(12345678, [1551234, 1591234])

          try:

              obj.find_arch('noarch', host, None)

              raise Exception('The BuildError Exception was not raised')

              self.assertEquals(e.message, 'No arch list for this host: test.domain.local')

      def test_BaseTaskHandler_find_arch_noarch_bad_tag(self):

          try:

              obj.find_arch('noarch', host, tag)

              raise Exception('The BuildError Exception was not raised')

              self.assertEquals(e.message, 'No arch list for tag: some_package-1.2-build')

      def test_BaseTaskHandler_find_arch_noarch(self):

          try:

              obj.find_arch('noarch', host, tag)

              raise Exception('The BuildError Exception was not raised')

              self.assertEquals(e.message, ('host test.domain.local (i386) does not support '

                                            'any arches of tag some_package-1.2-build (aarch64, x86_64)'))

          try:

              obj.getRepo(8472)

              raise Exception('The BuildError Exception was not raised')

              obj.session.getRepo.assert_called_once_with(8472)

              self.assertEquals(e.message, 'no repo (and no target) for tag rhel-7.3-build')

          obj = ForkTask(123, 'fork', [1, 20], None, None, (get_tmp_dir_path('ForkTask')))

          obj.run()

          mock_spawnvp.assert_called_once_with(1, 'sleep', ['sleep', '20'])