except ValueError:

              reason = "Failed to gather buildroot groups from SCM."

              log.exception(reason)

              session.commit()

              raise

          return groups

              )

          return module

          """Record that a build has transitioned state.

          The history of state transitions are recorded in model

          :type conf: :class:`Config`

          :param int state: the state value to transition to. Refer to ``BUILD_STATES``.

          :param str state_reason: optional reason of why to transform to ``state``.

          """

          now = datetime.utcnow()

          old_state = self.state

          self.state = state

          self.time_modified = now

          if INVERSE_BUILD_STATES[self.state] in ['done', 'failed']:

              self.time_completed = now

          if state_reason:

              self.state_reason = state_reason

  from flask import Blueprint, Response

  from prometheus_client import (  # noqa: F401

  from sqlalchemy import event

  # Service-specific imports

      'Number of messages, for which the sender failed',

      registry=registry)

  db_dbapi_error_counter = Counter(

      'db_dbapi_error',

      'Number of DBAPI errors',

                  if build:

                      session.refresh(build)

                      build.transition(conf, state=models.BUILD_STATES['failed'],

                      session.commit()

              log.debug("Done with %s" % idx)

      if (component_build.package == 'module-build-macros' and

         state != koji.BUILD_STATES['COMPLETE']):

          parent.transition(config, state=models.BUILD_STATES['failed'],

          session.commit()

          return

                  ', '.join(c.package for c in failed_components_in_batch))

              parent.transition(config,

                                state=models.BUILD_STATES['failed'],

              session.commit()

              return []

          elif not built_components_in_batch:

          if not build.state_reason:

              reason = "Missing koji tag. Assuming previously failed module lookup."

              log.error(reason)

              session.commit()

              return

      # Don't transition it again if it's already been transitioned

      if build.state != models.BUILD_STATES["failed"]:

      session.commit()

          time.sleep(1)

      error_msg = ''

      try:

          mmd = build.mmd()

          record_component_builds(mmd, build, session=session)

      except (UnprocessableEntity, Forbidden, ValidationError, RuntimeError) as e:

          log.exception(str(e))

          error_msg = str(e)

      except (xmlrpclib.ProtocolError, koji.GenericError) as e:

          log.exception(str(e))

          error_msg = 'Koji communication error: "{0}"'.format(str(e))

      except Exception as e:

          log.exception(str(e))

          error_msg = "An unknown error occurred while validating the modulemd"

      else:

          session.add(build)

          session.commit()

          if error_msg:

              # Rollback changes underway

              session.rollback()

  def generate_module_build_koji_tag(build):

      except ValueError:

          reason = "Failed to get module info from MBS. Max retries reached."

          log.exception(reason)

          session.commit()

          raise

      if module_build.component_builds and not good:

          state_reason = 'Component(s) {} failed to build.'.format(

              ', '.join(c.package for c in current_batch if c.state in failed_states))

          session.commit()

          log.warning("Odd!  All components in batch failed for %r." % module_build)

          return

              )

              module_build.transition(config,

                                      state=models.BUILD_STATES['failed'],

          else:

              # Tell the external buildsystem to wrap up (CG import, createrepo, etc.)

              module_build.time_completed = datetime.utcnow()

                  state_reason = ('The module was garbage collected since it has failed over {0}'

                                  ' day(s) ago'.format(conf.cleanup_failed_builds_time))

                  module.transition(

                  session.add(module)

                  session.commit()

                  state=build.state,

                  days=config.cleanup_stuck_builds_time

              )

              session.commit()

      def sync_koji_build_tags(self, config, session):

          c.state = koji.BUILD_STATES['FAILED']

          c.state_reason = "Failed to build artifact %s: %s" % (c.package, str(e))

          log.exception(e)

          return

      if not c.task_id and c.state == koji.BUILD_STATES['BUILDING']:

          c.state = koji.BUILD_STATES['FAILED']

          c.state_reason = ("Failed to build artifact %s: "

                            "Builder did not return task ID" % (c.package))

          return

              ', '.join([str(t['id']) for t in active_tasks])

          )

          module.transition(config, state=models.BUILD_STATES['failed'],

          session.commit()

          return []

  import os

  import pytest

  import requests

  import module_build_service.monitor

  from six.moves import reload_module

  class TestViews:

      assert len([l for l in r.text.splitlines()

                  if (l.startswith('# TYPE') and '_created ' not in l)]) == num_of_metrics