def getSRPMFromSCM(self, url, build_tag, repo_id):

          #TODO - allow different ways to get the srpm

          task_id = self.session.host.subtask(method='buildSRPMFromSCM',

                                              label='srpm',

                                              parent=self.id)

          # wait for subtask to finish

                  raise koji.BuildError('no repo for tag %s' % build_tag['name'])

          build_opts = dslice(opts, ['goals', 'profiles', 'properties', 'envs', 'patches',

                              strict=False)

          build_opts['repo_id'] = repo_id

          scm = SCM(url)

          scm.assert_allowed(self.options.allowed_scms)

          repo_id = opts.get('repo_id')

          if not repo_id:

              raise koji.BuildError('A repo_id must be provided')

          logfile = self.workdir + '/checkout.log'

          uploadpath = self.getUploadDir()

          # Check out sources from the SCM

          sourcedir = scm.checkout(scmdir, self.session, uploadpath, logfile)

          # zip up pristine sources for auditing purposes

          self._zip_dir(sourcedir, os.path.join(outputdir, 'scm-sources.zip'))

              patchlog = self.workdir + '/patches.log'

              patch_scm = SCM(self.opts.get('patches'))

              patch_scm.assert_allowed(self.options.allowed_scms)

              # never try to check out a common/ dir when checking out patches

              patch_scm.use_common = False

              patchcheckoutdir = patch_scm.checkout(patchdir, self.session, uploadpath, patchlog)

              self._zip_dir(patchcheckoutdir, os.path.join(outputdir, 'patches.zip'))

          # Apply patches, if present

          logfile = os.path.join(self.workdir, 'checkout.log')

          scmdir = buildroot.rootdir() + '/tmp/scmroot'

          koji.ensuredir(scmdir)

          specdir = scm.checkout(scmdir, self.session, self.getUploadDir(), logfile)

          spec_template = None

          for path, dir, files in os.walk(specdir):

          self.logger.debug("Image buildroot ready: " + broot.rootdir())

          return broot

          """

          Retrieve the kickstart file we were given (locally or remotely) and

          upload it.

          @args:

              broot: a buildroot object

              ksfile: path to a kickstart file

          @returns: absolute path to the retrieved kickstart file

          """

          scmdir = os.path.join(broot.rootdir(), 'tmp')

              scm = SCM(self.opts['ksurl'])

              scm.assert_allowed(self.options.allowed_scms)

              logfile = os.path.join(self.workdir, 'checkout.log')

              scmsrcdir = scm.checkout(scmdir, self.session, self.getUploadDir(), logfile)

              kspath = os.path.join(scmsrcdir, ksfile)

          else:

              kspath = self.localPath("work/%s" % ksfile)

          self.opts = opts

          broot = self.makeImgBuildRoot(build_tag, repo_info, arch,

                                        'appliance-build')

          self.readKickstart(kspath, opts)

          kskoji = self.prepareKickstart(repo_info, target_info, arch, broot, opts)

          # Figure out appliance-creator arguments, let it fail if something

          broot = self.makeImgBuildRoot(build_tag, repo_info, arch,

              'livecd-build')

          self.readKickstart(kspath, opts)

          kskoji = self.prepareKickstart(repo_info, target_info, arch, broot, opts)

          broot = self.makeImgBuildRoot(build_tag, repo_info, arch,

              'livemedia-build')

          self.readKickstart(kspath, opts)

          kskoji = self.prepareKickstart(repo_info, target_info, arch, broot, opts)

  class OzImageTask(BaseTaskHandler):

      Methods = []

          """

          Retrieve the kickstart file we were given (locally or remotely) and

          upload it to the hub.

          relative path in a remote scm. The user should have passed in an scm

          url with --ksurl.

          @returns:

              absolute path to the retrieved kickstart file

          """

              scm = SCM(self.opts['ksurl'])

              scm.assert_allowed(self.options.allowed_scms)

              logfile = os.path.join(self.workdir, 'checkout-%s.log' % self.arch)

              scmsrcdir = scm.checkout(self.workdir, self.session,

                  self.getUploadDir(), logfile)

              kspath = os.path.join(scmsrcdir, os.path.basename(ksfile))

          else:

              tops = dict([(k, getattr(self.options, k)) for k in 'topurl','topdir'])

          self.formats = self._format_deps(opts.get('format'))

          # First, prepare the kickstart to use the repos we tell it

          ks = self.prepareKickstart(kspath, inst_tree)

          kskoji = self.writeKickstart(ks,

              os.path.join(self.workdir, 'koji-%s-%i-base.ks' %

      # END inefficient base image task method copies

          """

          Retrieve a file either from the hub or a remote scm

          if fileurl:

              scm = SCM(fileurl)

              scm.assert_allowed(self.options.allowed_scms)

              logfile = os.path.join(self.workdir, 'checkout.log')

              scmsrcdir = scm.checkout(self.workdir, self.session,

                  self.getUploadDir(), logfile)

              final_path = os.path.join(scmsrcdir, os.path.basename(filepath))

          else:

              tops = dict([(k, getattr(self.options, k)) for k in 'topurl','topdir'])

              raise koji.ApplianceError('The Release may not have a hyphen')

          indirection_template = self.fetchHubOrSCM(opts.get('indirection_template'),

          self.logger.debug('Got indirection template %s' % (indirection_template))

          logfile = self.workdir + '/checkout.log'

          uploadpath = self.getUploadDir()

          # Check out spec file, etc. from SCM

          sourcedir = scm.checkout(scmdir, self.session, uploadpath, logfile)

          # chown the sourcedir and everything under it to the mockuser

          # so we can build the srpm as non-root

          uid = pwd.getpwnam(self.options.mockuser)[2]

  import koji

  import koji.tasks

  from koji.tasks import safe_rmtree

  import os

  import signal

  import logging

              # should never happen

              raise koji.GenericError('Invalid SCM URL: %s' % url)

      def _parse_url(self):

          """

          Parse the SCM url into usable components.

      def findHandlers(self, vars):

          """Find and index task handlers"""

          for v in vars.values():

      def scanPlugin(self, plugin):

          """Find task handlers in a plugin"""

      def shutdown(self):

          """Attempt to shut down cleanly"""

      'postRepoDone':           [],

      'preCommit':              [],

      'postCommit':             [],

      }

  class PluginTracker(object):

          return repo_info

  class FakeTask(BaseTaskHandler):

      Methods = ['someMethod']

      Foreground = True