# automagically detect production environment:

      #   - existing and readable config_file presets ProdConfiguration

      # try getting config_file from os.environ

      if 'FRESHMAKER_CONFIG_FILE' in os.environ:

          try:

              config_module = imp.load_source('freshmaker_runtime_config',

                                              config_file)

              raise SystemError("Configuration file {} was not found."

                                .format(config_file))

              'default': {},

              'desc': 'Whitelist for build targets of handlers',

          },

          'lightblue_server_url': {

              'type': str,

              'default': '',

                      # Do no try to convert None...

                      if value is not None:

                          value = convert(value)

                      raise TypeError("Configuration value conversion failed for name: %s" % key)

              # unknown type/unsupported conversion

              elif convert is not None:

  import abc

  import json

  import re

  from functools import wraps

  from freshmaker import conf, log, db, models

          db.session.commit()

          return build

          """

          Check whether the artifact is allowed to be built by checking

          HANDLER_BUILD_WHITELIST in config.

          :param artifact_type: an enum member of ArtifactType.

          """

          # Global rules

          whitelist_rules = conf.handler_build_whitelist.get("global", {})

          handler_name = self.name

          whitelist_rules.update(conf.handler_build_whitelist.get(handler_name, {}))

                      continue

                      return False

              return True

          try:

              whitelist = whitelist_rules.get(artifact_type.name.lower(), [])

                  log.debug('%r, type=%r is not whitelisted.',

          except re.error as exc:

              err_msg = ("Error while compiling whilelist rule "

                         "for <handler(%s) artifact(%s)>:\n"

                         (handler_name, artifact_type.name.lower(), str(exc)))

              log.error(err_msg)

              raise UnprocessableEntity(err_msg)

  class ContainerBuildHandler(BaseHandler):

          for container in containers:

              if not self.allow_build(ArtifactType.IMAGE, name=container['name'], branch=container['branch']):

                           container['name'], container['branch'])

                  continue

              try:

                  task_id = self.build_container(scm_url, branch, build_target)

                  if task_id is not None:

                      self.record_build(event, container['name'], ArtifactType.IMAGE, task_id)

                  log.exception('Error when rebuild %s', container)

          return []

          log.info('Start to rebuild docker image %s.', event.container)

          if not self.allow_build(ArtifactType.IMAGE, name=event.container, branch=event.branch):

                       event.container, event.branch)

              return []

          except koji.krbV.Krb5Error as e:

              log.exception('Failed to login Koji via Kerberos using GSSAPI. %s', e.args[1])

              log.exception('Could not create task to build docker image %s', event.container)

          return []

          log.info("Triggering rebuild of module %s:%s, metadata updated (%s).",

                   event.module, event.branch, event.rev)

          if not self.allow_build(ArtifactType.MODULE, name=event.module, branch=event.branch):

                       event.module, event.branch)

              return []

              name = module['variant_name']

              version = module['variant_version']

              if not self.allow_build(ArtifactType.MODULE, name=name, branch=version):

                           name, version)

                  continue

              log.info("Going to rebuild module '%s:%s'.", name, version)

                  name = mod['variant_name']

                  version = mod['variant_version']

                  if not self.allow_build(ArtifactType.MODULE, name=name, branch=version):

                               name, version)

                      continue

                  # bump module repo first

          logging.basicConfig(level=conf.log_level, format=log_format)

          try:

              from systemd import journal

              raise ValueError("systemd.journal module is not installed")

          log = logging.getLogger()

      msg_cert_subject.C = 'US'

      msg_cert_subject.ST = 'MA'

      msg_cert_subject.L = 'Boston'

      msg_cert_subject.CN = 'localhost'

      cert.set_serial_number(2)

      cert.gmtime_adj_notBefore(0)

      def _decorator(*args, **kwargs):

          try:

              return func(*args, **kwargs)

              db.session.rollback()

              raise

          finally:

      for submod_name in dir(mod):

          try:

              submod = getattr(mod, submod_name)

              continue

          key = None

          deps = []

  from tests import helpers

  from tests import get_fedmsg

  from freshmaker import events, db, models

  from freshmaker.types import ArtifactType

  from freshmaker.handlers.bodhi import BodhiUpdateCompleteStableHandler

      @mock.patch('freshmaker.handlers.bodhi.update_complete_stable.PDC')

      @mock.patch('freshmaker.handlers.bodhi.update_complete_stable.utils')

      @mock.patch('freshmaker.handlers.bodhi.update_complete_stable.conf')

      def test_trigger_rebuild_container_when_receives_bodhi_update_complete_stable_message(self, conf, utils, PDC):

          conf.git_base_url = 'git://pkgs.fedoraproject.org'

  from mock import patch

  from freshmaker import db

  from freshmaker.models import Event

  from freshmaker.types import EventState

          db.drop_all()

          db.session.commit()

      def test_event_state_updated_when_no_images_to_rebuild(self):

          self.mock_find_images_to_rebuild.return_value = iter([[[]]])

          event = ErrataAdvisoryRPMsSignedEvent(

  from mock import patch

  from mock import MagicMock, PropertyMock

  from freshmaker import db, models

  from freshmaker.consumer import FreshmakerConsumer

  from freshmaker.types import ArtifactType

      @patch('freshmaker.utils.krbContext')

      @patch("freshmaker.config.Config.krb_auth_principal",

             new_callable=PropertyMock, return_value="user@example.com")

      def test_rebuild_if_dockerfile_changed(

              self, auth_principal, krbContext, ClientSession, read_config):

          read_config.return_value = {

      @patch('koji.read_config')

      @patch('koji.ClientSession')

      def test_ensure_logout_in_whatever_case(self, ClientSession, read_config):

          ClientSession.return_value.buildContainer.side_effect = RuntimeError

          read_config.return_value = {

  sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))  # noqa

  from tests import helpers

  from freshmaker import events, db, models

  from freshmaker.types import ArtifactType

  from freshmaker.handlers.git import GitModuleMetadataChangeHandler

          handler = GitModuleMetadataChangeHandler()

          self.assertTrue(handler.can_handle(event))

      def test_can_rebuild_module_when_module_metadata_changed(self):

          """

          Tests handler can rebuild module when module metadata is changed in dist-git

  sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))  # noqa

  from tests import helpers

  from freshmaker import events, db, models

  from freshmaker.types import ArtifactType

  from freshmaker.handlers.git import GitRPMSpecChangeHandler

      @mock.patch('freshmaker.handlers.git.rpm_spec_change.PDC')

      @mock.patch('freshmaker.handlers.git.rpm_spec_change.utils')

      @mock.patch('freshmaker.handlers.git.rpm_spec_change.conf')

      def test_can_rebuild_modules_has_rpm_included(self, conf, utils, PDC):

          """

          Test handler can rebuild modules which include the rpm.

  from mock import patch, PropertyMock

  from unittest import TestCase

  from freshmaker import db

  from freshmaker.events import ErrataAdvisoryRPMsSignedEvent

  from freshmaker.handlers import ContainerBuildHandler

          self.assertRaises(ProgrammingError, handler.set_context, "something")

  class AnyStringWith(str):

      def __eq__(self, other):

          return self in other

                  self.assertEqual(build.build_id, None)

                  self.assertEqual(build.state, ArtifactBuildState.PLANNED.value)

      @patch('freshmaker.handlers.ODCS')

      @patch('koji.ClientSession')

      @patch('freshmaker.utils.krbContext')

  sys.path.insert(0, os.path.join(os.path.dirname(__file__), ".."))  # noqa

  from tests import helpers

  from freshmaker import events, db, models

  from freshmaker.types import ArtifactType

  from freshmaker.handlers.mbs import MBSModuleStateChangeHandler

      @mock.patch('freshmaker.handlers.mbs.module_state_change.PDC')

      @mock.patch('freshmaker.handlers.mbs.module_state_change.utils')

      @mock.patch('freshmaker.handlers.mbs.module_state_change.conf')

      def test_can_rebuild_depending_modules(self, conf, utils, PDC):

          """

          Tests handler can rebuild all modules which depend on the module

                  ],

              },

          }

          msg = helpers.ModuleStateChangeMessage('testmodule', 'master', state='ready').produce()

          event = self.get_event_from_msg(msg)

      @mock.patch('freshmaker.handlers.mbs.module_state_change.PDC')

      @mock.patch('freshmaker.handlers.mbs.module_state_change.utils')

      @mock.patch('freshmaker.handlers.mbs.module_state_change.log')

      def test_handler_not_fall_into_cyclic_rebuild_loop(self, log, utils, PDC):

          """

          Tests handler will not fall into cyclic rebuild loop when there is

  [flake8]

  ignore = E501,E731