pact_broker 2.4.2 → 2.5.0

data/lib/pact_broker/domain/webhook_request.rb

@@ -3,6 +3,7 @@ require 'pact_broker/domain/webhook_execution_result'
 require 'pact_broker/logging'
 require 'pact_broker/messages'
 require 'net/http'
+require 'pact_broker/webhooks/redact_logs'
 
 module PactBroker
 
@@ -46,60 +47,80 @@ module PactBroker
         password.nil? ? nil : "**********"
       end
 
-      def execute
-
+      def execute options = {}
         logs = StringIO.new
         execution_logger = Logger.new(logs)
-
         begin
-          req = http_request
-          execution_logger.info "HTTP/1.1 #{method.upcase} #{url_with_credentials}"
+          execute_and_build_result(options, logs, execution_logger)
+        rescue StandardError => e
+          handle_error_and_build_result(e, options, logs, execution_logger)
+        end
+      end
 
-          headers.each_pair do | name, value |
-            execution_logger.info "#{name}: #{value}"
-            req[name] = value
-          end
+      private
 
-          req.basic_auth(username, password) if username
+      def execute_and_build_result options, logs, execution_logger
+        req = build_request(execution_logger)
+        response = do_request(req)
+        log_response(response, execution_logger)
+        result = WebhookExecutionResult.new(response, logs.string)
+        log_completion_message(options, execution_logger, result.success?)
+        result
+      end
 
-          unless body.nil?
-            if String === body
-              req.body = body
-            else
-              req.body = body.to_json
-            end
-          end
+      def handle_error_and_build_result e, options, logs, execution_logger
+        logger.error "Error executing webhook #{uuid} #{e.class.name} - #{e.message} #{e.backtrace.join("\n")}"
+        execution_logger.error "Error executing webhook #{uuid} #{e.class.name} - #{e.message}"
+        log_completion_message(options, execution_logger, false)
+        WebhookExecutionResult.new(nil, logs.string, e)
+      end
+
+      def build_request execution_logger
+        req = http_request
+        execution_logger.info "HTTP/1.1 #{method.upcase} #{url_with_credentials}"
 
-          execution_logger.info req.body
+        headers.each_pair do | name, value |
+          execution_logger.info Webhooks::RedactLogs.call("#{name}: #{value}")
+          req[name] = value
+        end
 
-          logger.info "Making webhook #{uuid} request #{to_s}"
+        req.basic_auth(username, password) if username
 
-          response = Net::HTTP.start(uri.hostname, uri.port,
-            :use_ssl => uri.scheme == 'https') do |http|
-            http.request req
+        unless body.nil?
+          if String === body
+            req.body = body
+          else
+            req.body = body.to_json
           end
+        end
 
-          execution_logger.info(" ")
-          logger.info "Received response for webhook #{uuid} status=#{response.code}"
-          execution_logger.info "HTTP/#{response.http_version} #{response.code} #{response.message}"
-          response.each_header do | header |
-            execution_logger.info "#{header.split("-").collect(&:capitalize).join('-')}: #{response[header]}"
-          end
-          logger.debug "body=#{response.body}"
-          execution_logger.info response.body
-          WebhookExecutionResult.new(response, logs.string)
+        execution_logger.info req.body
+        req
+      end
 
-        rescue StandardError => e
-          logger.error "Error executing webhook #{uuid} #{e.class.name} - #{e.message}"
-          execution_logger.error "Error executing webhook #{uuid} #{e.class.name} - #{e.message}"
-          logger.error e.backtrace.join("\n")
-          execution_logger.error e.backtrace.join("\n")
-          WebhookExecutionResult.new(nil, logs.string, e)
+      def do_request req
+        logger.info "Making webhook #{uuid} request #{to_s}"
+        Net::HTTP.start(uri.hostname, uri.port,
+          :use_ssl => uri.scheme == 'https') do |http|
+          http.request req
         end
+      end
 
+      def log_response response, execution_logger
+        execution_logger.info(" ")
+        logger.info "Received response for webhook #{uuid} status=#{response.code}"
+        execution_logger.info "HTTP/#{response.http_version} #{response.code} #{response.message}"
+        response.each_header do | header |
+          execution_logger.info "#{header.split("-").collect(&:capitalize).join('-')}: #{response[header]}"
+        end
+        logger.debug "body=#{response.body}"
+        execution_logger.info response.body
       end
 
-      private
+      def log_completion_message options, execution_logger, success
+        execution_logger.info(options[:success_log_message]) if options[:success_log_message] && success
+        execution_logger.info(options[:failure_log_message]) if options[:failure_log_message] && !success
+      end
 
       def to_s
         "#{method.upcase} #{url}, username=#{username}, password=#{display_password}, headers=#{headers}, body=#{body}"
@@ -119,7 +140,5 @@ module PactBroker
         u
       end
     end
-
   end
-
 end

data/lib/pact_broker/pacticipants/service.rb

@@ -58,12 +58,14 @@ module PactBroker
         end
       end
 
+      # This needs to move into a new service
       def self.find_relationships
         pact_repository.find_latest_pacts
           .collect do | pact|
             latest_verification = verification_service.find_latest_verification_for(pact.consumer, pact.provider)
             webhooks = webhook_service.find_by_consumer_and_provider pact.consumer, pact.provider
-            PactBroker::Domain::Relationship.create pact.consumer, pact.provider, pact, latest_verification, webhooks
+            triggered_webhooks = webhook_service.find_latest_triggered_webhooks pact.consumer, pact.provider
+            PactBroker::Domain::Relationship.create pact.consumer, pact.provider, pact, latest_verification, webhooks, triggered_webhooks
           end
       end
 
@@ -83,7 +85,7 @@ module PactBroker
         version_ids = PactBroker::Domain::Version.where(pacticipant_id: pacticipant.id).select_for_subquery(:id) #stupid mysql doesn't allow subqueries
         select_pacticipant = "select id from pacticipants where name = '#{name}'"
         tag_repository.delete_by_version_id version_ids
-        webhook_repository.delete_executions_by_pacticipant pacticipant
+        webhook_service.delete_all_webhhook_related_objects_by_pacticipant pacticipant
         pact_repository.delete_by_version_id version_ids
         connection.run("delete from pact_publications where provider_id = #{pacticipant.id}")
         connection.run("delete from verifications where pact_version_id IN (select id from pact_versions where provider_id = #{pacticipant.id})")
@@ -92,7 +94,6 @@ module PactBroker
         connection.run("delete from pact_versions where consumer_id = #{pacticipant.id}")
         connection.run("delete from versions where pacticipant_id = #{pacticipant.id}")
         version_repository.delete_by_id version_ids
-        webhook_service.delete_by_pacticipant pacticipant
         connection.run("delete from pacticipants where id = #{pacticipant.id}")
       end
 

data/lib/pact_broker/pacts/repository.rb

@@ -112,6 +112,14 @@ module PactBroker
         query.limit(1).collect(&:to_domain_with_content)[0]
       end
 
+      def find_all_revisions consumer_name, consumer_version, provider_name
+        AllPactPublications
+          .consumer(consumer_name)
+          .provider(provider_name)
+          .consumer_version_number(consumer_version)
+          .order(:consumer_version_order, :revision_number).collect(&:to_domain_with_content)
+      end
+
       def find_previous_pact pact
         LatestPactPublicationsByConsumerVersion
           .eager(:tags)

data/lib/pact_broker/pacts/service.rb

@@ -31,6 +31,8 @@ module PactBroker
 
       def delete params
         logger.info "Deleting pact version with params #{params}"
+        pacts = pact_repository.find_all_revisions(params[:consumer_name], params[:consumer_version_number], params[:provider_name])
+        webhook_service.delete_all_webhook_related_objects_by_pact_publication_ids(pacts.collect(&:id))
         pact_repository.delete(params)
       end
 

data/lib/pact_broker/services.rb

@@ -42,7 +42,7 @@ module PactBroker
       Verifications::Service
     end
 
-    def badges_service
+    def badge_service
       require 'pact_broker/badges/service'
       Badges::Service
     end

data/lib/pact_broker/ui/view_models/relationship.rb

@@ -37,8 +37,35 @@ module PactBroker
           @relationship.any_webhooks?
         end
 
-        def webhooks_url
-          url = PactBroker::Api::PactBrokerUrls.webhooks_for_pact_url @relationship.latest_pact.consumer, @relationship.latest_pact.provider, ''
+        def webhook_label
+          case @relationship.webhook_status
+            when :none then "Create"
+            when :success, :failure then webhook_last_execution_date
+            when :retrying then "Retrying"
+            when :not_run then "Not run"
+          end
+        end
+
+        def webhook_status
+          case @relationship.webhook_status
+            when :success then "success"
+            when :failure then "danger"
+            when :retrying then "warning"
+            else ""
+          end
+        end
+
+        def webhook_last_execution_date
+          PactBroker::DateHelper.distance_of_time_in_words(@relationship.last_webhook_execution_date, DateTime.now) + " ago"
+        end
+
+        def webhook_url
+          url = case @relationship.webhook_status
+            when :none
+              PactBroker::Api::PactBrokerUrls.webhooks_for_pact_url @relationship.latest_pact.consumer, @relationship.latest_pact.provider
+            else
+              PactBroker::Api::PactBrokerUrls.webhooks_status_url @relationship.latest_pact.consumer, @relationship.latest_pact.provider
+          end
           "/hal-browser/browser.html##{url}"
         end
 

data/lib/pact_broker/ui/views/relationships/show.haml

@@ -26,11 +26,11 @@
           %span.glyphicon.glyphicon-sort.relationships-sort
         %th
         %th
-          Latest pact published
+          Latest pact<br>published
         %th
-          Webhooks
+          Webhook<br>status
         %th
-          Last verified
+          Last<br>verified
       %tbody
 
       - relationships.each do | relationship |
@@ -48,13 +48,10 @@
           %td
           %td
             = relationship.publication_date_of_latest_pact
-          %td
-            - if relationship.any_webhooks?
-              %a{:href => relationship.webhooks_url}
-                Edit
-            - else
-              %a{:href => relationship.webhooks_url}
-                Create
+          %td{class: relationship.webhook_status}
+            %a{:href => relationship.webhook_url}
+              = relationship.webhook_label
+
           %td{class: relationship.verification_status, title: relationship.verification_tooltip, "data-toggle": "tooltip", "data-placement": "left"}
             %div
               = relationship.last_verified_date

data/lib/pact_broker/verifications/repository.rb

@@ -19,6 +19,7 @@ module PactBroker
 
       def find consumer_name, provider_name, pact_version_sha, verification_number
         PactBroker::Domain::Verification
+          .select_all_qualified
           .join(:all_pact_publications, pact_version_id: :pact_version_id)
           .consumer(consumer_name)
           .provider(provider_name)
@@ -30,6 +31,7 @@ module PactBroker
         # Use LatestPactPublicationsByConsumerVersion not AllPactPublcations because we don't
         # want verifications for shadowed revisions as it would be misleading.
         LatestVerificationsByConsumerVersion
+          .select_all_qualified
           .join(:latest_pact_publications_by_consumer_versions, pact_version_id: :pact_version_id)
           .consumer(consumer_name)
           .consumer_version_number(consumer_version_number)
@@ -39,6 +41,7 @@ module PactBroker
 
       def find_latest_verification_for consumer_name, provider_name, tag = nil
         query = LatestVerificationsByConsumerVersion
+          .select_all_qualified
           .join(:all_pact_publications, pact_version_id: :pact_version_id)
           .consumer(consumer_name)
           .provider(provider_name)
@@ -47,7 +50,11 @@ module PactBroker
         elsif tag
           query = query.tag(tag)
         end
-        query.latest.single_record
+        query.reverse_order(
+          Sequel[:all_pact_publications][:consumer_version_order],
+          Sequel[:all_pact_publications][:revision_number],
+          Sequel[LatestVerificationsByConsumerVersion.table_name][:number]
+        ).limit(1).single_record
       end
 
       def pact_version_id_for pact

data/lib/pact_broker/version.rb

@@ -1,3 +1,3 @@
 module PactBroker
-  VERSION = '2.4.2'
+  VERSION = '2.5.0'
 end

data/lib/pact_broker/webhooks/execution.rb

@@ -1,14 +1,35 @@
 require 'sequel'
+require 'pact_broker/db'
+require 'pact_broker/repositories/helpers'
+
 
 module PactBroker
   module Webhooks
-    class Execution < Sequel::Model(:webhook_executions)
+    class Execution < Sequel::Model(
+      PactBroker::DB.connection[:webhook_executions].select(
+        Sequel[:webhook_executions][:id],
+        :triggered_webhook_id,
+        :success,
+        :logs,
+        Sequel[:webhook_executions][:created_at])
+      )
+
+      dataset_module do
+        include PactBroker::Repositories::Helpers
+      end
+
+      associate(:many_to_one, :triggered_webhook, :class => "PactBroker::Webhooks::TriggeredWebhook", :key => :triggered_webhook_id, :primary_key => :id)
 
-      associate(:many_to_one, :webhook, :class => "PactBroker::Webhooks::Webhook", :key => :webhook_id, :primary_key => :id)
-      associate(:many_to_one, :pact_publication, :class => "PactBroker::Pacts::PactPublication", :key => :pact_publication_id, :primary_key => :id)
+      def <=> other
+        comp = created_date <=> other.created_date
+        comp = id <=> other.id if comp == 0
+        comp
+      end
+    end
+
+    class DeprecatedExecution < Sequel::Model(:webhook_executions)
       associate(:many_to_one, :provider, :class => "PactBroker::Domain::Pacticipant", :key => :provider_id, :primary_key => :id)
       associate(:many_to_one, :consumer, :class => "PactBroker::Domain::Pacticipant", :key => :consumer_id, :primary_key => :id)
-
     end
 
     Execution.plugin :timestamps

data/lib/pact_broker/webhooks/job.rb

@@ -6,17 +6,20 @@ module PactBroker
   module Webhooks
     class Job
 
-      BACKOFF_TIMES = [10, 60, 120, 300, 600, 1200] #10 sec, 1 min, 2 min, 5 min, 10 min, 20 min => 38 minutes
-
       include SuckerPunch::Job
       include PactBroker::Logging
 
       def perform data
-        @webhook = data[:webhook]
+        @data = data
+        @triggered_webhook = data[:triggered_webhook]
         @error_count = data[:error_count] || 0
         begin
-          webhook_execution_result = PactBroker::Webhooks::Service.execute_webhook_now webhook
-          reschedule_job unless webhook_execution_result.success?
+          webhook_execution_result = PactBroker::Webhooks::Service.execute_triggered_webhook_now triggered_webhook, execution_options
+          if webhook_execution_result.success?
+            handle_success
+          else
+            handle_failure
+          end
         rescue StandardError => e
           handle_error e
         end
@@ -24,23 +27,62 @@ module PactBroker
 
       private
 
-      attr_reader :webhook, :error_count
+      attr_reader :triggered_webhook, :error_count
+
+      def execution_options
+        {
+          success_log_message: "Successfully executed webhook",
+          failure_log_message: failure_log_message
+        }
+      end
+
+      def failure_log_message
+        if reschedule_job?
+          "Retrying webhook in #{backoff_time} seconds"
+        else
+          "Webhook execution failed after #{retry_schedule.size + 1} attempts"
+        end
+      end
 
       def handle_error e
         log_error e
-        reschedule_job
+        handle_failure
       end
 
-      def reschedule_job
-        case error_count
-        when 0...BACKOFF_TIMES.size
-          logger.debug "Re-enqeuing job for webhook #{webhook.uuid} to run in #{BACKOFF_TIMES[error_count]} seconds"
-          Job.perform_in(BACKOFF_TIMES[error_count], {webhook: webhook, error_count: error_count+1})
+      def handle_success
+        update_triggered_webhook_status TriggeredWebhook::STATUS_SUCCESS
+      end
+
+      def handle_failure
+        if reschedule_job?
+          reschedule_job
+          update_triggered_webhook_status TriggeredWebhook::STATUS_RETRYING
         else
-          logger.error "Failed to execute webhook #{webhook.uuid} after #{BACKOFF_TIMES.size} times."
+          logger.error "Failed to execute webhook #{triggered_webhook.webhook_uuid} after #{retry_schedule.size + 1} attempts."
+          update_triggered_webhook_status TriggeredWebhook::STATUS_FAILURE
         end
       end
 
+      def reschedule_job?
+        error_count < retry_schedule.size
+      end
+
+      def reschedule_job
+        logger.debug "Re-enqeuing job for webhook #{triggered_webhook.webhook_uuid} to run in #{backoff_time} seconds"
+        Job.perform_in(backoff_time, @data.merge(error_count: error_count+1))
+      end
+
+      def update_triggered_webhook_status status
+        PactBroker::Webhooks::Service.update_triggered_webhook_status triggered_webhook, status
+      end
+
+      def backoff_time
+        retry_schedule[error_count]
+      end
+
+      def retry_schedule
+        PactBroker.configuration.webhook_retry_schedule
+      end
     end
   end
 end

data/lib/pact_broker/webhooks/latest_triggered_webhook.rb

@@ -0,0 +1,9 @@
+require 'pact_broker/webhooks/triggered_webhook'
+
+module PactBroker
+  module Webhooks
+    class LatestTriggeredWebhook < TriggeredWebhook
+      set_dataset(:latest_triggered_webhooks)
+    end
+  end
+end

data/lib/pact_broker/webhooks/redact_logs.rb

@@ -0,0 +1,10 @@
+module PactBroker
+  module Webhooks
+    class RedactLogs
+      def self.call logs
+        logs.gsub(/(Authorization: )(.*)/i,'\1[REDACTED]')
+            .gsub(/(Token: )(.*)/i,'\1[REDACTED]')
+      end
+    end
+  end
+end

data/lib/pact_broker/webhooks/repository.rb

@@ -3,6 +3,8 @@ require 'pact_broker/domain/webhook'
 require 'pact_broker/domain/pacticipant'
 require 'pact_broker/db'
 require 'pact_broker/webhooks/webhook'
+require 'pact_broker/webhooks/triggered_webhook'
+require 'pact_broker/webhooks/latest_triggered_webhook'
 require 'pact_broker/webhooks/execution'
 
 module PactBroker
@@ -26,6 +28,16 @@ module PactBroker
         Webhook.where(uuid: uuid).limit(1).collect(&:to_domain)[0]
       end
 
+      def update_by_uuid uuid, webhook
+        existing_webhook = Webhook.find(uuid: uuid)
+        existing_webhook.update_from_domain(webhook).save
+        existing_webhook.headers.collect(&:delete)
+        webhook.request.headers.each_pair do | name, value |
+          existing_webhook.add_header PactBroker::Webhooks::WebhookHeader.from_domain(name, value, existing_webhook.id)
+        end
+        find_by_uuid uuid
+      end
+
       def delete_by_uuid uuid
         Webhook.where(uuid: uuid).destroy
       end
@@ -43,23 +55,79 @@ module PactBroker
         Webhook.where(consumer_id: consumer.id, provider_id: provider.id).collect(&:to_domain)
       end
 
-      def create_execution webhook, webhook_execution_result
+      def find_by_consumer_and_provider_existing_at consumer, provider, date_time
+        Webhook.where(consumer_id: consumer.id, provider_id: provider.id)
+        .where(Sequel.lit("created_at < ?", date_time))
+        .collect(&:to_domain)
+      end
+
+      def create_triggered_webhook trigger_uuid, webhook, pact, trigger_type
         db_webhook = Webhook.where(uuid: webhook.uuid).single_record
-        execution = Execution.create(
+        TriggeredWebhook.create(
+          status: TriggeredWebhook::STATUS_NOT_RUN,
+          pact_publication_id: pact.id,
           webhook: db_webhook,
+          webhook_uuid: db_webhook.uuid,
+          trigger_uuid: trigger_uuid,
+          trigger_type: trigger_type,
           consumer: db_webhook.consumer,
-          provider: db_webhook.provider,
+          provider: db_webhook.provider
+        )
+      end
+
+      def update_triggered_webhook_status triggered_webhook, status
+        triggered_webhook.update(status: status)
+      end
+
+      def create_execution triggered_webhook, webhook_execution_result
+        Execution.create(
+          triggered_webhook: triggered_webhook,
           success: webhook_execution_result.success?,
           logs: webhook_execution_result.logs)
       end
 
-      def delete_executions_by_pacticipant pacticipant
-        Execution.where(consumer: pacticipant).delete
-        Execution.where(provider: pacticipant).delete
+      def delete_triggered_webhooks_by_pacticipant pacticipant
+        TriggeredWebhook.where(consumer: pacticipant).delete
+        TriggeredWebhook.where(provider: pacticipant).delete
+      end
+
+      def delete_executions_by_pacticipant pacticipants
+        # TODO this relationship no longer exists, deprecate in next version
+        DeprecatedExecution.where(consumer: pacticipants).delete
+        DeprecatedExecution.where(provider: pacticipants).delete
+        execution_ids = Execution
+          .join(:triggered_webhooks, {id: :triggered_webhook_id})
+          .where(Sequel.or(
+            Sequel[:triggered_webhooks][:consumer_id] => [*pacticipants].collect(&:id),
+            Sequel[:triggered_webhooks][:provider_id] => [*pacticipants].collect(&:id),
+          )).all.collect(&:id)
+        Execution.where(id: execution_ids).delete
+      end
+
+      def unlink_triggered_webhooks_by_webhook_uuid uuid
+        TriggeredWebhook.where(webhook: Webhook.where(uuid: uuid)).update(webhook_id: nil)
+        DeprecatedExecution.where(webhook_id: Webhook.where(uuid: uuid).select(:id)).update(webhook_id: nil)
+      end
+
+      def delete_triggered_webhooks_by_pact_publication_ids pact_publication_ids
+        triggered_webhook_ids = TriggeredWebhook.where(pact_publication_id: pact_publication_ids).select_for_subquery(:id)
+        Execution.where(triggered_webhook_id: triggered_webhook_ids).delete
+        TriggeredWebhook.where(id: triggered_webhook_ids).delete
+        DeprecatedExecution.where(pact_publication_id: pact_publication_ids).delete
+      end
+
+      def find_latest_triggered_webhooks consumer, provider
+        LatestTriggeredWebhook
+          .where(consumer: consumer, provider: provider)
+          .order(:id)
+          .all
+          .group_by{|w| [w.consumer_id, w.provider_id, w.webhook_uuid]}
+          .values
+          .collect(&:last)
       end
 
-      def unlink_executions_by_webhook_uuid uuid
-        Execution.where(webhook: Webhook.where(uuid: uuid)).update(webhook_id: nil)
+      def fail_retrying_triggered_webhooks
+        TriggeredWebhook.retrying.update(status: TriggeredWebhook::STATUS_FAILURE)
       end
     end
   end