RUNNING = 3

      PENDING = 4

      SKIPPED = 5

      @classmethod

      def string(cls, number):

              self.update_process_title("Waiting for an action task from frontend for {}s"

                                        .format(int(time.time() - get_action_init_time)))

              try:

                          auth=("user", self.opts.frontend_auth))

                  action_task = r.json()

              except (RequestException, ValueError) as error:

  from ..exceptions import DispatchBuildError, NoVmAvailable

  from ..job import BuildJob

  from ..vm_manage.manager import VmManager

  from .worker import Worker

  from collections import defaultdict

  class BuildDispatcher(multiprocessing.Process):

      """

      """

      def __init__(self, opts):

      def get_vm_group_ids(self, arch):

          if not arch:

              return [group["id"] for group in self.opts.build_groups]

          try:

              return self.arch_to_groups[arch]

          except KeyError:

              self.update_process_title("Waiting for jobs from frontend for {} s"

                                        .format(int(time.time() - get_task_init_time)))

              try:

                             auth=("user", self.opts.frontend_auth)).json()

              except (RequestException, ValueError) as error:

      def can_build_start(self, job):

          """

          Returns

          -------

          False if the build can not start (build is cancelled)

          """

          try:

          except (RequestException, ValueError) as error:

              self.log.exception("Communication with Frontend to confirm build start failed with error: {}".format(error))

              return False

                  self.log.info("Removed finished worker {} for job {}"

                                .format(worker.worker_id, worker.job.task_id))

      def start_worker(self, vm, job, reattach=False):

          worker = Worker(

              opts=self.opts,

              self.clean_finished_workers()

              for job in self.load_jobs():

                  # if we found it, spawn a worker to reattach

                  vm = self.vm_manager.get_vm_by_task_id(job.task_id)

                  if vm and vm.state == 'in_use':

          return False

      def init_buses(self):

          self.log.info(self.opts.msg_buses)

          for bus_config in self.opts.msg_buses:

              self.msg_buses.append(MsgBusStomp(bus_config, self.log))

                      self.log.exception("Unexpected error")

                      failed = True

                  if not failed:

                      try:

                          mr.on_success_build()

          return built_packages

      def get_srpm_url(self, job):

          try:

              pattern = os.path.join(job.results_dir, '*.src.rpm')

              srpm_name = os.path.basename(glob.glob(pattern)[0])

              self.log.exception("Building error: {}".format(error))

          except Exception as e:

              self.log.exception("Unexpected error: {}".format(e))

          """

          self._post_to_frontend_repeatedly(data, "update")

          """

          Announce to the frontend that a build is starting.

          Return: True if the build can start

                  False if the build can not start (can be cancelled or deleted)

          """

          response = self._post_to_frontend_repeatedly(data, "starting_build")

          if "can_start" not in response.json():

              raise RequestException("Bad respond from the frontend")

                  raise BuilderError("Build host `{}` missing mock config for chroot `{}`"

                                     .format(self.hostname, self.job.chroot))

  class SrpmBuilder(Builder):

      def _copr_builder_cmd(self):

          return 'copr-rpmbuild --verbose --drop-resultdir '\

          for val in [True, False]:

              ptfr.return_value.json.return_value = {"can_start": val}

      def test_starting_build_err(self):

          ptfr = MagicMock()

          self.fc._post_to_frontend_repeatedly = ptfr

          with pytest.raises(RequestException):

      def test_starting_build_err_2(self):

          ptfr = MagicMock()

          ptfr.return_value.json.return_value = {}

          with pytest.raises(RequestException):

      def test_reschedule_build(self):

          ptfr = MagicMock()

  class ImportTask(object):

      def __init__(self):

          self.owner = None

          self.project = None

          self.branches = []

          task = ImportTask()

          try:

              task.owner = task_dict["owner"]

              task.project = task_dict["project"]

              task.branches = task_dict["branches"]

              # get the data

              r = get(self.get_url)

              # take the first task

              if not builds:

                  log.debug("No new tasks to process.")

              log.error("Failed to post back to frontend : {}".format(data_dict))

              log.exception(str(e))

      def do_import(self, task):

          """

          :type task: ImportTask

          per_task_log_handler = self.setup_per_task_logging(task)

          workdir = tempfile.mkdtemp()

          try:

              srpm_path = helpers.download_file(

                  task.srpm_url,

                  workdir

              )

                  self.opts,

                  task.repo_namespace,

                  task.branches,

                  srpm_path

          except PackageImportException as e:

              log.exception("Exception raised during package import.")

          finally:

              shutil.rmtree(workdir)

          self.teardown_per_task_logging(per_task_log_handler)

      def setup_per_task_logging(self, task):

          handler = logging.FileHandler(

              os.path.join(self.opts.per_task_log_dir,

          )

          handler.setLevel(logging.DEBUG)

          logging.getLogger('').addHandler(handler)

                  continue

              for mb_task in mb_tasks:

                  pool.append(p)

                  log.info("Starting worker '{}' with task '{}' (timeout={})"

                  p.start()

              log.info("Going to terminate worker '{}' with task '{}' due to exceeded timeout {} seconds"

                       .format(worker.name, worker.id, worker.timeout))

              worker.terminate()

              log.info("Worker '{}' with task '{}' was terminated".format(worker.name, worker.timeout))

      def remove_dead(self):

          self.FILE_HASH = "1234abc"

          self.url_task_data = {

              "owner": self.USER_NAME,

              "project": self.PROJECT_NAME,

              "srpm_url": "http://example.com/pkg.src.rpm",

          }

          self.upload_task_data = {

              "owner": self.USER_NAME,

              "project": self.PROJECT_NAME,

  class TestImporter(Base):

      def test_try_to_obtain_new_task_empty(self, mc_get):

          assert len(self.importer.try_to_obtain_new_tasks()) is 0

      def test_try_to_obtain_handle_error(self, mc_get):

              assert len(self.importer.try_to_obtain_new_tasks()) is 0

      def test_try_to_obtain_ok(self, mc_get):

          task = self.importer.try_to_obtain_new_tasks()[0]

          assert task.owner == self.USER_NAME

          assert self.BRANCH in task.branches

          assert task.srpm_url == "http://example.com/pkg.src.rpm"

      def test_try_to_obtain_ok_2(self, mc_get):

          task = self.importer.try_to_obtain_new_tasks()[0]

          assert task.owner == self.USER_NAME

          assert self.BRANCH in task.branches

          assert task.srpm_url == "http://front/tmp/tmp_2/pkg_2.src.rpm"

      def test_try_to_obtain_new_task_unknown_source_type_ok_3(self, mc_get):

          task_data = copy.deepcopy(self.url_task_data)

          task_data["source_type"] = 999999

          task = self.importer.try_to_obtain_new_tasks()[0]

      def test_post_back(self, mc_post):

          dd = {"foo": "bar"}

          assert mc_import_package.call_args[0][3] == 'somepath.src.rpm'

          print self.importer.post_back_safe.has_calls([

                    'pkg_version': '1.2', 'git_hash': '123', 'repo_name': 'foo'}),

                    'pkg_version': '1.2', 'git_hash': '124', 'repo_name': 'foo'})

          ])

          self.importer.do_import.side_effect = stop_run

          self.importer.run()

          mc_worker.assert_called_with(target=self.importer.do_import, args=[self.url_task],

          pool.terminate_timeouted(callback=send_to_fe)

          w.join()

          assert not pool[0].is_alive()

  class UnknownSourceTypeException(Exception):

      pass

  class NoPackageSourceException(Exception):

      pass

          "pending": "Your build is waiting for a builder.",

          "skipped": "This package has already been built previously.",

          "starting": "Trying to acquire and configure builder for task.",

      }

      return description_map.get(state, "")

  class StatusEnum(with_metaclass(EnumType, object)):

  class ModuleStatusEnum(with_metaclass(EnumType, object)):

  from coprs import models

  from coprs import helpers

  from coprs.constants import DEFAULT_BUILD_TIMEOUT, MAX_BUILD_TIMEOUT

  from coprs.helpers import StatusEnum

  from coprs.logic import coprs_logic

          """

          Returns Builds which are waiting to be uploaded to dist git

          """

                   .filter(models.Build.canceled == false())

          return query

      @classmethod

          return query

      @classmethod

                  .filter(models.Build.canceled == false())

                  .order_by(models.Build.is_background.asc(), models.Build.id.asc())

                  .all())

      @classmethod

          return (models.BuildChroot.query.join(models.Build)

                  .filter(models.Build.canceled == false())

                  .filter(or_(

                          models.BuildChroot.ended_on.is_(None)

                      )

                  ))

                  .all())

      @classmethod

      @classmethod

      def get_copr_builds_list(cls, copr):

          query_select = """

      MIN(statuses.started_on) AS started_on, MAX(statuses.ended_on) AS ended_on, order_to_status(MIN(statuses.st)) AS status,

      build.canceled, MIN("group".name) AS group_name, MIN(copr.name) as copr_name, MIN("user".username) as user_name

  FROM build

                      return 6

                  elif x == 5:

                      return 7

                      return 8

                  return 1000

              def sqlite_order_to_status(x):

                  elif x == 7:

                      return 5

                  elif x == 8:

                      return 8

                  return 1000

              conn = db.engine.connect()

          git_hashes = {}

          if source_build.source_type == helpers.BuildSourceEnum('upload'):

          build = cls.create_new(user, copr, source_build.source_type, source_build.source_json, chroot_names,

                                      pkgs=source_build.pkgs, git_hashes=git_hashes, skip_import=skip_import,

              repos=None, chroots=None, timeout=None, enable_net=True,

              git_hashes=None, skip_import=False, background=False, batch=None,

              srpm_url=None):

          if chroots is None:

              chroots = []

              source_type = helpers.BuildSourceEnum("link")

              source_json = json.dumps({"url":pkgs})

          build = models.Build(

              user=user,

              pkgs=pkgs,

              repos=repos,

              source_type=source_type,

              source_json=source_json,

              submitted_on=int(time.time()),

              enable_net=bool(enable_net),

              is_background=bool(background),

          if not chroots:

              chroots = copr.active_chroots

          for chroot in chroots:

              git_hash = None

              if git_hashes:

                  git_hash = git_hashes.get(chroot.name)

              buildchroot = models.BuildChroot(

                  build=build,

                  mock_chroot=chroot,

                  git_hash=git_hash,

              )

                 }]

              }

          """

              # update respective chroot status

              for build_chroot in build.build_chroots:

                  if build_chroot.name == upd_dict["chroot"]:

                      if "status" in upd_dict and build_chroot.status not in BuildsLogic.terminal_states:

                          build_chroot.status = upd_dict["status"]

                              and all(b.status == StatusEnum("succeeded") for b in build.module.builds)):

                          ActionsLogic.send_build_module(build.copr, build.module)

          db.session.add(build)

      @classmethod

                  "You are not allowed to cancel this build.")

          if not build.cancelable:

              if build.status == StatusEnum("starting"):