pact_broker 2.77.0 → 2.80.0

data/lib/pact_broker/webhooks/status.rb

@@ -2,7 +2,7 @@ module PactBroker
   module Webhooks
     class Status
 
-      def initialize pact, webhooks, latest_triggered_webhooks
+      def initialize _pact, webhooks, latest_triggered_webhooks
         @webhooks = webhooks
         @latest_triggered_webhooks = latest_triggered_webhooks
       end
@@ -11,6 +11,7 @@ module PactBroker
         to_sym.to_s
       end
 
+      # rubocop: disable Metrics/CyclomaticComplexity
       def to_sym
         return :none if webhooks.empty?
         return :not_run if latest_triggered_webhooks.empty? || latest_triggered_webhooks.all?{|w| w.status == "not_run"}
@@ -19,6 +20,7 @@ module PactBroker
         end
         latest_triggered_webhooks.all?{|w| w.status == "success"} ? :success : :failure
       end
+      # rubocop: enable Metrics/CyclomaticComplexity
 
       private
 

data/lib/pact_broker/webhooks/trigger_service.rb

@@ -1,9 +1,11 @@
-require 'pact_broker/services'
-require 'pact_broker/hash_refinements'
+require "pact_broker/services"
+require "pact_broker/hash_refinements"
 
 module PactBroker
   module Webhooks
     module TriggerService
+      RESOURCE_CREATION = PactBroker::Webhooks::TriggeredWebhook::TRIGGER_TYPE_RESOURCE_CREATION
+      USER = PactBroker::Webhooks::TriggeredWebhook::TRIGGER_TYPE_USER
 
       extend self
       extend PactBroker::Repositories
@@ -11,69 +13,70 @@ module PactBroker
       include PactBroker::Logging
       using PactBroker::HashRefinements
 
-      def trigger_webhooks_for_new_pact(pact, event_context, webhook_options)
-        webhook_service.trigger_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, event_context, webhook_options
-        if pact_is_new_or_newly_tagged_or_pact_has_changed_since_previous_version?(pact)
-          webhook_service.trigger_webhooks pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, webhook_options
-        else
-          logger.info "Pact content has not changed since previous version, not triggering webhooks for changed content"
+      def next_uuid
+        SecureRandom.uuid
+      end
+
+      # TODO support currently deployed
+      def test_execution webhook, event_context, execution_configuration
+        merged_options = execution_configuration.with_failure_log_message("Webhook execution failed").to_hash
+
+        verification = nil
+        if webhook.trigger_on_provider_verification_published?
+          verification = verification_service.search_for_latest(webhook.consumer_name, webhook.provider_name) || PactBroker::Verifications::PlaceholderVerification.new
         end
+
+        pact = pact_service.search_for_latest_pact(consumer_name: webhook.consumer_name, provider_name: webhook.provider_name) || PactBroker::Pacts::PlaceholderPact.new
+        webhook.execute(pact, verification, event_context.merge(event_name: "test"), merged_options)
       end
 
-      def trigger_webhooks_for_updated_pact(existing_pact, updated_pact, event_context, webhook_options)
-        webhook_service.trigger_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_PUBLISHED, event_context, webhook_options
-        # TODO this should use the sha!
-        if existing_pact.pact_version_sha != updated_pact.pact_version_sha
-          logger.info "Existing pact for version #{existing_pact.consumer_version_number} has been updated with new content, triggering webhooks for changed content"
-          webhook_service.trigger_webhooks updated_pact, nil, PactBroker::Webhooks::WebhookEvent::CONTRACT_CONTENT_CHANGED, event_context, webhook_options
+      def execute_triggered_webhook_now triggered_webhook, webhook_execution_configuration_hash
+        webhook_execution_result = triggered_webhook.execute webhook_execution_configuration_hash
+        webhook_repository.create_execution triggered_webhook, webhook_execution_result
+        webhook_execution_result
+      end
+
+      # the main entry point
+      def create_triggered_webhooks_for_event pact, verification, event_name, event_context
+        webhooks = webhook_repository.find_webhooks_to_trigger(consumer: pact.consumer, provider: pact.provider, event_name: event_name)
+
+        if webhooks.any?
+          create_triggered_webhooks_for_webhooks(webhooks, pact, verification, event_name, event_context.merge(event_name: event_name))
         else
-          logger.info "Pact content has not changed since previous revision, not triggering webhooks for changed content"
+          []
         end
       end
 
-      def trigger_webhooks_for_verification_results_publication(pact, verification, event_context, webhook_options)
-        expand_events(event_context).each do | reconstituted_event_context |
-          if verification.success
-            webhook_service.trigger_webhooks(
-              pact,
-              verification,
-              PactBroker::Webhooks::WebhookEvent::VERIFICATION_SUCCEEDED,
-              reconstituted_event_context,
-              webhook_options
-            )
-          else
-            webhook_service.trigger_webhooks(
-              pact,
-              verification,
-              PactBroker::Webhooks::WebhookEvent::VERIFICATION_FAILED,
-              reconstituted_event_context,
-              webhook_options
-            )
-          end
+      # private
+      def create_triggered_webhooks_for_webhooks webhooks, pact, verification, event_name, event_context
+        webhooks.flat_map do | webhook |
+          expanded_event_contexts = expand_events_for_currently_deployed_environments(webhook, pact, event_context)
+          expanded_event_contexts = expanded_event_contexts.flat_map { | ec | expand_events_for_verification_of_multiple_selected_pacts(ec) }
 
-          webhook_service.trigger_webhooks(
-            pact,
-            verification,
-            PactBroker::Webhooks::WebhookEvent::VERIFICATION_PUBLISHED,
-            reconstituted_event_context,
-            webhook_options
-          )
+          expanded_event_contexts.collect do | expanded_event_context |
+            pact_for_triggered_webhook = verification ? find_pact_for_verification_triggered_webhook(pact, expanded_event_context) : pact
+            webhook_repository.create_triggered_webhook(next_uuid, webhook, pact_for_triggered_webhook, verification, RESOURCE_CREATION, event_name, expanded_event_context)
+          end
         end
       end
 
-      private
+      def schedule_webhooks(triggered_webhooks, options)
+        triggered_webhooks.each_with_index do | triggered_webhook, i |
+          logger.info "Scheduling job for webhook with uuid #{triggered_webhook.webhook.uuid}, context: #{triggered_webhook.event_context}"
+          logger.debug "Schedule webhook with options #{options}"
 
-      def pact_is_new_or_newly_tagged_or_pact_has_changed_since_previous_version? pact
-        changed_pacts = pact_repository
-          .find_previous_pacts(pact)
-          .reject { |_, previous_pact| !sha_changed_or_no_previous_version?(previous_pact, pact) }
-        print_debug_messages(changed_pacts)
-        changed_pacts.any?
+          job_data = { triggered_webhook: triggered_webhook }.deep_merge(options)
+          begin
+            # Delay slightly to make sure the request transaction has finished before we execute the webhook
+            Job.perform_in(5 + (i * 3), job_data)
+          rescue StandardError => e
+            logger.warn("Error scheduling webhook execution for webhook with uuid #{triggered_webhook&.webhook&.uuid}", e)
+            nil
+          end
+        end
       end
 
-      def sha_changed_or_no_previous_version?(previous_pact, new_pact)
-        previous_pact.nil? || new_pact.pact_version_sha != previous_pact.pact_version_sha
-      end
+      private
 
       def merge_consumer_version_selectors(consumer_version_number, selectors, event_context)
         event_context.merge(
@@ -91,8 +94,8 @@ module PactBroker
       # Actually, we used to trigger one webhook per tag, but given that the most likely use of the
       # verification published webhook is for reporting git statuses,
       # it makes more sense to trigger per consumer version number (ie. commit).
-      def expand_events(event_context)
-        triggers = if event_context[:consumer_version_selectors].is_a?(Array)
+      def expand_events_for_verification_of_multiple_selected_pacts(event_context)
+        if event_context[:consumer_version_selectors].is_a?(Array)
           event_context[:consumer_version_selectors]
             .group_by{ | selector | selector[:consumer_version_number] }
             .collect { | consumer_version_number, selectors | merge_consumer_version_selectors(consumer_version_number, selectors, event_context.without(:consumer_version_selectors)) }
@@ -101,24 +104,26 @@ module PactBroker
         end
       end
 
-      def print_debug_messages(changed_pacts)
-        if changed_pacts.any?
-          messages = changed_pacts.collect do |tag, previous_pact|
-            if tag == :untagged
-              if previous_pact
-                "pact content has changed since previous untagged version"
-              else
-                "first time untagged pact published"
-              end
-            else
-              if previous_pact
-                "pact content has changed since the last consumer version tagged with #{tag}"
-              else
-                "first time pact published with consumer version tagged #{tag}"
-              end
-            end
+      def expand_events_for_currently_deployed_environments(webhook, pact, event_context)
+        if PactBroker.feature_enabled?(:expand_currently_deployed_provider_versions) && webhook.expand_currently_deployed_provider_versions?
+          deployed_version_service.find_currently_deployed_versions_for_pacticipant(pact.provider).collect(&:version_number).uniq.collect do | version_number |
+            event_context.merge(currently_deployed_provider_version_number: version_number)
           end
-          logger.info("Webhook triggered for the following reasons: #{messages.join(',')}" )
+        else
+          [event_context]
+        end
+      end
+
+      def find_pact_for_verification_triggered_webhook(pact, reconstituted_event_context)
+        if reconstituted_event_context[:consumer_version_number]
+          find_pact_params = {
+            consumer_name: pact.consumer_name,
+            provider_name: pact.provider_name,
+            consumer_version_number: reconstituted_event_context[:consumer_version_number]
+          }
+          pact_service.find_pact(find_pact_params) || pact
+        else
+          pact
         end
       end
     end

data/lib/pact_broker/webhooks/triggered_webhook.rb

@@ -1,7 +1,7 @@
-require 'sequel'
-require 'pact_broker/repositories/helpers'
-require 'pact_broker/webhooks/execution'
-require 'pact_broker/hash_refinements'
+require "sequel"
+require "pact_broker/repositories/helpers"
+require "pact_broker/webhooks/execution"
+require "pact_broker/hash_refinements"
 
 # Represents the relationship between a webhook and the event and object
 # that caused it to be triggered. eg a pact publication
@@ -13,19 +13,19 @@ module PactBroker
       plugin :timestamps, update_on_create: true
       plugin :serialization, :json, :event_context
 
-      TRIGGER_TYPE_RESOURCE_CREATION = 'resource_creation'
-      TRIGGER_TYPE_USER = 'user'
+      TRIGGER_TYPE_RESOURCE_CREATION = "resource_creation"
+      TRIGGER_TYPE_USER = "user"
 
-      STATUS_NOT_RUN = 'not_run'.freeze
-      STATUS_RETRYING = 'retrying'.freeze
-      STATUS_SUCCESS = 'success'.freeze
-      STATUS_FAILURE = 'failure'.freeze
+      STATUS_NOT_RUN = "not_run".freeze
+      STATUS_RETRYING = "retrying".freeze
+      STATUS_SUCCESS = "success".freeze
+      STATUS_FAILURE = "failure".freeze
 
       dataset_module do
         include PactBroker::Repositories::Helpers
 
         def delete
-          require 'pact_broker/webhooks/execution'
+          require "pact_broker/webhooks/execution"
           PactBroker::Webhooks::Execution.where(triggered_webhook: self).delete
           super
         end
@@ -55,7 +55,8 @@ module PactBroker
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
 
       def request_description
-        webhook.to_domain.request_description
+        # webhook could be deleted
+        webhook&.to_domain&.request_description
       end
 
       def execute options
@@ -124,8 +125,10 @@ end
 #  verification_id     | integer                     |
 #  event_name          | text                        |
 #  event_context       | text                        |
+#  uuid                | text                        |
 # Indexes:
 #  triggered_webhooks_pkey                      | PRIMARY KEY btree (id)
+#  triggered_webhooks_uuid                      | UNIQUE btree (uuid)
 #  uq_triggered_webhook_ppi_wi                  | UNIQUE btree (pact_publication_id, webhook_id, trigger_uuid)
 #  uq_triggered_webhook_wi                      | UNIQUE btree (webhook_id, trigger_uuid)
 #  triggered_webhooks_consumer_id_index         | btree (consumer_id)

data/lib/pact_broker/webhooks/webhook.rb

@@ -1,7 +1,7 @@
-require 'sequel'
-require 'pact_broker/domain/webhook'
-require 'pact_broker/webhooks/webhook_request_template'
-require 'pact_broker/domain/pacticipant'
+require "sequel"
+require "pact_broker/domain/webhook"
+require "pact_broker/webhooks/webhook_request_template"
+require "pact_broker/domain/pacticipant"
 
 module PactBroker
   module Webhooks
@@ -17,6 +17,37 @@ module PactBroker
       dataset_module do
         include PactBroker::Repositories::Helpers
 
+        # Keep the triggered webhooks after the webhook has been deleted
+        def delete
+          require "pact_broker/webhooks/triggered_webhook"
+          TriggeredWebhook.where(webhook: self).update(webhook_id: nil)
+          super
+        end
+
+        def for_event_name(event_name)
+          join(:webhook_events, { webhook_id: :id })
+            .where(Sequel[:webhook_events][:name] => event_name)
+        end
+
+        def find_by_consumer_and_or_provider consumer, provider
+          where(
+            Sequel.|(
+              { consumer_id: consumer.id, provider_id: provider.id },
+              { consumer_id: nil, provider_id: provider.id },
+              { consumer_id: consumer.id, provider_id: nil },
+              { consumer_id: nil, provider_id: nil}
+            )
+          )
+        end
+
+        def find_by_consumer_and_provider consumer, provider
+          criteria = {
+            consumer_id: (consumer ? consumer.id : nil),
+            provider_id: (provider ? provider.id : nil)
+          }
+          where(criteria)
+        end
+
         def enabled
           where(enabled: true)
         end
@@ -62,7 +93,7 @@ module PactBroker
 
       def parsed_body
         if body && is_json_request_body
-           JSON.parse(body)
+          JSON.parse(body)
         else
           body
         end
@@ -72,7 +103,13 @@ module PactBroker
         (consumer_id == integration.consumer_id || !consumer_id) && (provider_id == integration.provider_id || !provider_id)
       end
 
-      private
+      # Keep the triggered webhooks after the webhook has been deleted
+      def delete
+        require "pact_broker/webhooks/triggered_webhook"
+        TriggeredWebhook.where(webhook_id: id).update(webhook_id: nil)
+        super
+      end
+
 
       def self.properties_hash_from_domain webhook
         is_json_request_body = !(String === webhook.request.body || webhook.request.body.nil?) # Can't rely on people to set content type

data/lib/pact_broker/webhooks/webhook_event.rb

@@ -1,16 +1,16 @@
-require 'sequel'
-require 'pact_broker/repositories/helpers'
+require "sequel"
+require "pact_broker/repositories/helpers"
 
 module PactBroker
   module Webhooks
     class WebhookEvent < Sequel::Model
       plugin :timestamps, update_on_create: true
 
-      CONTRACT_PUBLISHED = 'contract_published'
-      CONTRACT_CONTENT_CHANGED = 'contract_content_changed'
-      VERIFICATION_PUBLISHED = 'provider_verification_published'
-      VERIFICATION_SUCCEEDED = 'provider_verification_succeeded'
-      VERIFICATION_FAILED = 'provider_verification_failed'
+      CONTRACT_PUBLISHED = "contract_published"
+      CONTRACT_CONTENT_CHANGED = "contract_content_changed"
+      VERIFICATION_PUBLISHED = "provider_verification_published"
+      VERIFICATION_SUCCEEDED = "provider_verification_succeeded"
+      VERIFICATION_FAILED = "provider_verification_failed"
       DEFAULT_EVENT_NAME = CONTRACT_CONTENT_CHANGED
 
       EVENT_NAMES = [CONTRACT_PUBLISHED, CONTRACT_CONTENT_CHANGED, VERIFICATION_PUBLISHED, VERIFICATION_SUCCEEDED, VERIFICATION_FAILED]

data/lib/pact_broker/webhooks/webhook_execution_result.rb

@@ -1,5 +1,5 @@
-require 'pact_broker/webhooks/http_request_with_redacted_headers'
-require 'pact_broker/webhooks/http_response_with_utf_8_safe_body'
+require "pact_broker/webhooks/http_request_with_redacted_headers"
+require "pact_broker/webhooks/http_response_with_utf_8_safe_body"
 
 module PactBroker
   module Webhooks
@@ -14,7 +14,12 @@ module PactBroker
       end
 
       def success?
-        !response.nil? && response.code.to_i < 300
+        if response
+          # Response HTTP Code must be in success list otherwise it is false
+          PactBroker.configuration.webhook_http_code_success.include? response.code.to_i
+        else
+          false
+        end
       end
     end
   end

data/lib/pact_broker/webhooks/webhook_request_logger.rb

@@ -1,7 +1,7 @@
-require 'pact_broker/messages'
-require 'pact_broker/logging'
-require 'pact_broker/webhooks/http_request_with_redacted_headers'
-require 'pact_broker/webhooks/http_response_with_utf_8_safe_body'
+require "pact_broker/messages"
+require "pact_broker/logging"
+require "pact_broker/webhooks/http_request_with_redacted_headers"
+require "pact_broker/webhooks/http_response_with_utf_8_safe_body"
 
 module PactBroker
   module Webhooks
@@ -13,7 +13,7 @@ module PactBroker
       class Formatter < Logger::Formatter
         Format = "[%s] %s: %s\n".freeze
 
-        def call(severity, time, progname, msg)
+        def call(severity, time, _progname, msg)
           Format % [format_datetime(time), severity, msg2str(msg)]
         end
 
@@ -71,7 +71,7 @@ module PactBroker
       end
 
       def response_body_hidden_message(base_url)
-        PactBroker::Messages.message('messages.response_body_hidden', base_url: base_url)
+        PactBroker::Messages.message("messages.response_body_hidden", base_url: base_url)
       end
 
       def log_response_to_application_logger uuid, response
@@ -117,9 +117,11 @@ module PactBroker
       end
 
       def success?(response)
-        unless response.nil?
+        if response
           # Response HTTP Code must be in success list otherwise it is false
           PactBroker.configuration.webhook_http_code_success.include? response.code.to_i
+        else
+          false
         end
       end
 

data/lib/pact_broker/webhooks/webhook_request_template.rb

@@ -1,8 +1,7 @@
-require 'pact_broker/domain/webhook_request_header'
-require 'pact_broker/webhooks/render'
-require 'cgi'
-require 'pact_broker/domain/webhook_request'
-require 'pact_broker/string_refinements'
+require "pact_broker/webhooks/render"
+require "cgi"
+require "pact_broker/domain/webhook_request"
+require "pact_broker/string_refinements"
 
 module PactBroker
   module Webhooks
@@ -14,7 +13,8 @@ module PactBroker
 
       HEADERS_TO_REDACT = [/authorization/i, /token/i]
 
-      attr_accessor :method, :url, :headers, :body, :username, :password, :uuid
+      attr_accessor :method, :url, :body, :username, :password, :uuid
+      attr_reader :headers
 
       # Reform gets confused by the :method method, as :method is a standard
       # Ruby method.
@@ -62,13 +62,48 @@ module PactBroker
         @headers = Rack::Utils::HeaderHash.new(headers)
       end
 
+      def uses_parameter?(parameter_name)
+        !!body_string&.include?("${" + parameter_name + "}")
+      end
+
+      def body_string
+        String === body ? body : body&.to_json
+      end
 
       def to_s
         "#{method.upcase} #{url}, username=#{username}, password=#{display_password}, headers=#{redacted_headers}, body=#{body}"
       end
 
+      def template_parameters(scope = nil)
+        body_template_parameters(scope) + url_template_parameters(scope) + header_template_parameters(scope) + credentials_template_parameters(scope)
+      end
+
+      def body_template_parameters(scope = nil)
+        body_string.scan(parameter_pattern(scope)).flatten.uniq
+      end
+
+      def header_template_parameters(scope = nil)
+        pattern = parameter_pattern(scope)
+        headers.values.collect { |value| value.scan(pattern) }.flatten.uniq
+      end
+
+      def url_template_parameters(scope = nil)
+        url.scan(parameter_pattern(scope)).flatten.uniq
+      end
+
+      def credentials_template_parameters(scope = nil)
+        pattern = parameter_pattern(scope)
+        [username, password].compact.collect do | credential |
+          credential.scan(pattern)
+        end.flatten.uniq
+      end
+
       private
 
+      def parameter_pattern(scope)
+        scope ? /\${(#{scope}\.[a-zA-z]+)}/ : /\${([a-zA-z]+\.[a-zA-z]+)}/
+      end
+
       def build_url(template_params)
         URI(PactBroker::Webhooks::Render.call(url, template_params){ | value | CGI::escape(value) if !value.nil? } ).to_s
       end