- ./docker/home:/home/dev:Z

        - ./docker/greenwave-settings.py:/etc/greenwave/settings.py:ro,z

        - ./conf/policies/:/etc/greenwave/policies/:ro,z

      ports:

        - 8080:8080

      depends_on:

  from greenwave.safe_yaml import SafeYAMLError

  from greenwave.utils import insert_headers, jsonp

  from greenwave.waivers import waive_answers

  from greenwave.monitor import (

      registry,

      decision_exception_counter,

  log = logging.getLogger(__name__)

  def _decision_subjects_for_request(data):

              log.error('Missing required "subject_identifier" parameter')

              raise BadRequest('Missing required "subject_identifier" parameter')

  @api.route('/version', methods=['GET'])

      return resp

  @api.route('/decision', methods=['OPTIONS'])

  @jsonp

  def make_decision_options():

      on_demand_policies = []

      if rules:

          request_data = {key: data[key] for key in data if key not in ('subject', 'subject_type')}

              on_demand_policy = OnDemandPolicy.create_from_json(request_data)

              on_demand_policies.append(on_demand_policy)

      waiver_filters = []

      policies = on_demand_policies or current_app.config['policies']

          subject_policies = [

              policy for policy in policies

              if policy.matches(

                  decision_context=decision_context,

                  product_version=product_version,

          ]

          if not subject_policies:

                  continue

              log.error(

                  'Cannot find any applicable policies for %s subjects at gating point %s in %s',

              raise NotFound(

                  'Cannot find any applicable policies for %s subjects at gating point %s in %s' % (

          if verbose:

              # Retrieve test results and waivers for all items when verbose output is requested.

              waiver_filters.append(dict(

                  product_version=product_version,

              ))

              answers.extend(

                  policy.check(

                      product_version,

                      results_retriever))

          applicable_policies.extend(subject_policies)

          for answer in answers:

              if not answer.is_satisfied:

                  waiver_filters.append(dict(

                      product_version=product_version,

                      testcase=answer.test_case_name,

                  ))

  from greenwave.monitor import monitor_api

  from greenwave.utils import json_error, load_config, sha1_mangle_key

  from greenwave.policies import load_policies, RemoteRule

  from dogpile.cache import make_region

  from requests import ConnectionError, Timeout

      log.debug("config: Loading policies from %r", policies_dir)

      app.config['policies'] = load_policies(policies_dir)

      if not _can_use_remote_rule(app.config) and _has_remote_rule(app.config['policies']):

          raise RuntimeError(

              "If you want to apply a RemoteRule"

  import os

  class Config(object):

      """

      A GreenWave Flask configuration.

      REQUESTS_VERIFY = True

      POLICIES_DIR = '/etc/greenwave/policies'

      MESSAGING = 'fedmsg'

      #WAIVERDB_API_URL = 'http://waiverdb-dev.fedorainfracloud.org/api/v1.0'

      WAIVERDB_API_URL = 'http://localhost:5004/api/v1.0'

      GREENWAVE_API_URL = 'http://localhost:5005/api/v1.0'

  class TestingConfig(Config):

      WAIVERDB_API_URL = 'http://localhost:5004/api/v1.0'

      GREENWAVE_API_URL = 'http://localhost:5005/api/v1.0'

      KOJI_BASE_URL = 'http://localhost:5006/kojihub'

  import fedmsg.consumers

  import greenwave.app_factory

  from greenwave.monitor import (

      publish_decision_exceptions_result_counter,

      messaging_tx_to_send_counter, messaging_tx_stopped_counter,

      def _publish_decision_change(

              self,

              submit_time,

              testcase,

              product_version,

              publish_testcase):

          policy_attributes = dict(

              testcase=testcase,

          )

                  submit_time,

                  decision_context=decision_context,

                  product_version=product_version,

              )

              if decision is None:

                  continue

                  continue

              decision.update({

                  # subject is for backwards compatibility only:

                  'decision_context': decision_context,

                  'product_version': product_version,

                  'previous': old_decision,

  from greenwave.consumers.consumer import Consumer

  from greenwave.product_versions import subject_product_version

  import xmlrpc.client

              self.koji_proxy = None

      @staticmethod

          """

          consideration from the message.

          Args:

          except KeyError:

              data = message['msg']['task']  # Old format

          # note: it is *intentional* that we do not handle old format

          # compose-type messages, because it is impossible to reliably

          # produce a decision from these. compose decisions can only be

          # https://pagure.io/taskotron/resultsdb/issue/92

          # https://pagure.io/taskotron/resultsdb/pull-request/101

          # https://pagure.io/greenwave/pull-request/262#comment-70350

      def _consume_message(self, message):

          msg = message['msg']

          brew_task_id = _get_brew_task_id(msg)

  """

  from greenwave.consumers.consumer import Consumer

  class WaiverDBHandler(Consumer):

          product_version = msg['product_version']

          testcase = msg['testcase']

          submit_time = msg['timestamp']

          self._publish_decision_change(

              submit_time=submit_time,

              testcase=testcase,

              product_version=product_version,

              publish_testcase=True,

  from greenwave.utils import remove_duplicates, to_hashable

  from greenwave.safe_yaml import (

      SafeYAMLBool,

      SafeYAMLList,

      SafeYAMLObject,

      SafeYAMLString,

      pass

  class Answer(object):

      """

      Represents the result of evaluating a policy rule against a particular

      ResultsDB with a matching item and test case name).

      """

          self.test_case_name = test_case_name

          self.scenario = scenario

          return {

              'type': 'test-result-missing',

              'testcase': self.test_case_name,

              'scenario': self.scenario,

              # For backwards compatibility only:

          }

      def to_waived(self):

          return TestResultMissingWaived(

              self.test_case_name,

              self.scenario)

      """

      Same as TestResultMissing but the result was waived.

      """

          self.test_case_name = test_case_name

          self.scenario = scenario

          return {

              'type': 'test-result-missing-waived',

              'testcase': self.test_case_name,

              'scenario': self.scenario,

          }

      not ``PASSED`` or ``INFO``) and no corresponding waiver was found.

      """

          self.test_case_name = test_case_name

          self.scenario = scenario

          self.result_id = result_id

              # These are for backwards compatibility only

              # (the values are already visible in the result data itself, the

              # caller shouldn't need them repeated here):

              'scenario': self.scenario,

          }

      Remote policy parsing failed.

      """

          self.test_case_name = test_case_name

          self.details = details

          return {

              'type': 'invalid-gating-yaml',

              'testcase': self.test_case_name,

              'details': self.details

          }

      test_case_name = 'missing-gating-yaml'

      def to_json(self):

          return {

              'type': 'missing-gating-yaml',

              'testcase': self.test_case_name,

          }

      def to_waived(self):

              self,

              policy,

              product_version,

              results_retriever):

          """

          Evaluate this policy rule for the given item.

          Args:

              policy (Policy): Parent policy of the rule

              product_version (str): Product version we are making a decision about

                  example, Koji build NVR, Bodhi update id, ...)

              results_retriever (ResultsRetriever): Object for retrieving data

                  from ResultsDB.

          'required': SafeYAMLBool(optional=True, default=False),

      }

              return []

          try:

              pkg_namespace, pkg_name, rev = greenwave.resources.retrieve_scm_from_koji(

              )

          except greenwave.resources.NoSourceException as e:

              log.error(e)

              self,

              policy,

              product_version,

              results_retriever):

          try:

          except SafeYAMLError as e:

              return [

              ]

          if policies is None:

              if self.required:

              return []

          answers = []

          for remote_policy in policies:

              if remote_policy.matches_product_version(product_version):

                  response = remote_policy.check(

                  if isinstance(response, list):

                      answers.extend(response)

      def matches(self, policy, **attributes):

          #pylint: disable=broad-except

              return True

          sub_policies = []

          try:

          except SafeYAMLError:

          except Exception:

          if sub_policies is None:

          return any(sub_policy.matches(**attributes) for sub_policy in sub_policies)

              self,

              policy,

              product_version,

              results_retriever):

          if self.scenario is not None:

              matching_results = [

          # Investigate the absence of result first.

          if not matching_results:

          # If we find multiple matching results, we always use the first one which

          # will be the latest chronologically, because ResultsDB always returns

          # results ordered by `submit_time` descending.

      def matches(self, policy, **attributes):

          testcase = attributes.get('testcase')

              'scenario': self.scenario,

          }

          if result['outcome'] in ('PASSED', 'INFO'):

              log.debug('Test result passed for the result_id %s and testcase %s,'

                        ' because the outcome is %s', result['id'], self.test_case_name,

              return TestResultPassed(self.test_case_name, result['id'])

          if result['outcome'] in ('QUEUED', 'RUNNING'):

                        self.test_case_name, result['outcome'])

                    'testcase %s, because the outcome is %s and it didn\'t match any of the '

  class ObsoleteRule(Rule):

              self,

              policy,

              product_version,

              results_retriever):

          raise ValueError('This rule is obsolete and can\'t be checked')

          'id': SafeYAMLString(),

          'product_versions': SafeYAMLList(str),

          'decision_context': SafeYAMLString(),

          'subject_type': SafeYAMLString(),

          'rules': SafeYAMLList(Rule),

          'blacklist': SafeYAMLList(str, optional=True),

          if product_version and not self.matches_product_version(product_version):

              return False

              return False

          return not self.rules or any(rule.matches(self, **attributes) for rule in self.rules)

      def check(

              self,

              product_version,

              results_retriever):

          # If an item is about a package and it is in the blacklist, return RuleSatisfied()

              if name in self.blacklist:

              for exclude in self.excluded_packages:

                  if fnmatch(name, exclude):

              if self.packages and not any(fnmatch(name, package) for package in self.packages):

                  # If the `packages` whitelist is set and this package isn't in the

                  # `packages` whitelist, then the policy doesn't apply to it

              response = rule.check(