pact_broker 2.65.0 → 2.66.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2f74ca577601716567fbf1b435dba1a2d0c8b3cec8d3c9f77ca3930ce83e49bd
-  data.tar.gz: 3920435e5b898db13b39808b43a0f40de770674ecf99ce84e3587b4658a1b0a5
+  metadata.gz: 2ded381f9c89732b48d2d27f1f9dc7c26708a54c407c6a777a0f698c221d03b5
+  data.tar.gz: 9ac73a1fde0c35b5cc5870e8006556bcc74a5c3765d86ba373b9a91040657b14
 SHA512:
-  metadata.gz: 72e1efd36d6f4ccce34a9e7088ee0232678721606710a5d2a91f74d72ddb0b1d4642645ab26083af05683343f928818132ec37eab0b76e54efc0077fe4d474ea
-  data.tar.gz: 0dee5c2f282ca4a21e25502a4ea2c3d11dae57931e196297f4d3fcda46f6bfec82c155899e69975f72f79c16bc34813ce38b6bd9171c4d4d45238564f0d21255
+  metadata.gz: 15667e1349e7ff6a2484016659d1eee0a26d95471ea6f0f959135f72b2fcf68714a550421a1ff239efa089514ef0064a07602cd84c22f60fedfc82b30a2337a0
+  data.tar.gz: e1c836e2cc3b82096ee5d03c9fe215e5010a7b0eef2aad43781a8713e5e8f8b987fbc86c19d5b5c95c819831a6d07f953a3b8b552d6104b3daddc5a1e62680d0

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+<a name="v2.66.0"></a>
+### v2.66.0 (2020-10-01)
+
+#### Features
+
+* paginate pacticipant versions	 ([f489ba7b](/../../commit/f489ba7b))
+
+* **webhooks**
+  * add event name to group by clause when selecting latest triggered webhooks	 ([134f12c8](/../../commit/134f12c8))
+
+#### Bug Fixes
+
+* maintain latest and tag params when submitting page after following link from can-i-deploy debug logs	 ([6e2f1a85](/../../commit/6e2f1a85))
+
 <a name="v2.65.0"></a>
 ### v2.65.0 (2020-09-25)
 

data/db/ddl_statements/latest_triggered_webhooks.rb

@@ -0,0 +1,66 @@
+# These views find the latest triggered webhook for each webhook/consumer/provider
+# by finding the latest execution date for each webhook
+# then taking the row with the max ID in case there there are two
+# triggered webhooks for the same UUID and same creation date
+# Not sure if this is strictly necessary to do the extra step, but better to be
+# safe than sorry.
+# I probably could just take the max ID for each webhook/consumer/provider, but
+# something in my head says that
+# relying on the primary key for order is not a good idea, even though
+# according to the SQL it should be fine.
+def latest_triggered_webhook_creation_dates_v2
+  "select webhook_uuid, consumer_id, provider_id, max(created_at) as latest_triggered_webhook_created_at
+  from triggered_webhooks
+  group by webhook_uuid, consumer_id, provider_id"
+end
+
+# Ignore ltwcd.latest_triggered_webhook_created_at, it's there because postgres doesn't allow you to modify
+# the names and types of columns in a view
+def latest_triggered_webhook_ids_v2
+  "select tw.webhook_uuid, tw.consumer_id, tw.provider_id, ltwcd.latest_triggered_webhook_created_at, max(tw.id) as latest_triggered_webhook_id
+  from latest_triggered_webhook_creation_dates ltwcd
+  inner join triggered_webhooks tw
+  on tw.consumer_id = ltwcd.consumer_id
+  and tw.provider_id = ltwcd.provider_id
+  and tw.webhook_uuid = ltwcd.webhook_uuid
+  and tw.created_at = ltwcd.latest_triggered_webhook_created_at
+  group by tw.webhook_uuid, tw.consumer_id, tw.provider_id, ltwcd.latest_triggered_webhook_created_at"
+end
+
+def latest_triggered_webhooks_v2
+  "select tw.*
+  from triggered_webhooks tw
+  inner join latest_triggered_webhook_ids ltwi
+  on tw.consumer_id = ltwi.consumer_id
+  and tw.provider_id = ltwi.provider_id
+  and tw.webhook_uuid = ltwi.webhook_uuid
+  and tw.id = ltwi.latest_triggered_webhook_id"
+end
+
+# use explicit columns - can't drop event_name in 20200922_add_event_to_triggered_webhook.rb
+# if tw.* is used because you can't remove columns from a view in postgres
+def latest_triggered_webhooks_v3_rollback(is_postgres)
+  if is_postgres
+    "select tw.id, tw.trigger_uuid, tw.trigger_type, tw.pact_publication_id, tw.webhook_id, tw.webhook_uuid, tw.consumer_id, tw.provider_id, tw.status, tw.created_at, tw.updated_at, tw.verification_id, ''::text as event_name
+    from triggered_webhooks tw
+    inner join latest_triggered_webhook_ids ltwi
+    on tw.consumer_id = ltwi.consumer_id
+    and tw.provider_id = ltwi.provider_id
+    and tw.webhook_uuid = ltwi.webhook_uuid
+    and tw.id = ltwi.latest_triggered_webhook_id"
+  else
+    latest_triggered_webhooks_v2
+  end
+end
+
+##### v3
+
+# screw dates, just use IDs.
+def latest_triggered_webhooks_v3
+  "select tw.id, tw.trigger_uuid, tw.trigger_type, tw.pact_publication_id, tw.webhook_id, tw.webhook_uuid, tw.consumer_id, tw.provider_id, tw.status, tw.created_at, tw.updated_at, tw.verification_id, tw.event_name
+  from triggered_webhooks tw
+  inner join (select max(id) as max_id
+    from triggered_webhooks
+    group by webhook_uuid, consumer_id, provider_id, event_name) latest_ids
+  on latest_ids.max_id = tw.id"
+end

data/db/migrations/20180119_update_latest_triggered_webhooks.rb

@@ -1,44 +1,10 @@
+require_relative '../ddl_statements/latest_triggered_webhooks'
+
 Sequel.migration do
   up do
-    # These views find the latest triggered webhook for each webhook/consumer/provider
-    # by finding the latest execution date for each webhook
-    # then taking the row with the max ID in case there there are two
-    # triggered webhooks for the same UUID and same creation date
-    # Not sure if this is strictly necessary to do the extra step, but better to be
-    # safe than sorry.
-    # I probably could just take the max ID for each webhook/consumer/provider, but
-    # something in my head says that
-    # relying on the primary key for order is not a good idea, even though
-    # according to the SQL it should be fine.
-
-    create_or_replace_view(:latest_triggered_webhook_creation_dates,
-      "select webhook_uuid, consumer_id, provider_id, max(created_at) as latest_triggered_webhook_created_at
-      from triggered_webhooks
-      group by webhook_uuid, consumer_id, provider_id"
-    )
-
-    # Ignore ltwcd.latest_triggered_webhook_created_at, it's there because postgres doesn't allow you to modify
-    # the names and types of columns in a view
-    create_or_replace_view(:latest_triggered_webhook_ids,
-      "select tw.webhook_uuid, tw.consumer_id, tw.provider_id, ltwcd.latest_triggered_webhook_created_at, max(tw.id) as latest_triggered_webhook_id
-      from latest_triggered_webhook_creation_dates ltwcd
-      inner join triggered_webhooks tw
-      on tw.consumer_id = ltwcd.consumer_id
-      and tw.provider_id = ltwcd.provider_id
-      and tw.webhook_uuid = ltwcd.webhook_uuid
-      and tw.created_at = ltwcd.latest_triggered_webhook_created_at
-      group by tw.webhook_uuid, tw.consumer_id, tw.provider_id, ltwcd.latest_triggered_webhook_created_at"
-    )
-
-    create_or_replace_view(:latest_triggered_webhooks,
-      "select tw.*
-      from triggered_webhooks tw
-      inner join latest_triggered_webhook_ids ltwi
-      on tw.consumer_id = ltwi.consumer_id
-      and tw.provider_id = ltwi.provider_id
-      and tw.webhook_uuid = ltwi.webhook_uuid
-      and tw.id = ltwi.latest_triggered_webhook_id"
-    )
+    create_or_replace_view(:latest_triggered_webhook_creation_dates, latest_triggered_webhook_creation_dates_v2)
+    create_or_replace_view(:latest_triggered_webhook_ids, latest_triggered_webhook_ids_v2)
+    create_or_replace_view(:latest_triggered_webhooks, latest_triggered_webhooks_v2)
   end
 
   down do

data/db/migrations/20200930_update_latest_triggered_webhooks.rb

@@ -0,0 +1,15 @@
+require_relative '../ddl_statements/latest_triggered_webhooks'
+require_relative 'migration_helper'
+
+Sequel.migration do
+  up do
+    # TODO
+    # drop_view(:latest_triggered_webhook_ids)
+    # drop_view(:latest_triggered_webhook_creation_dates)
+    create_or_replace_view(:latest_triggered_webhooks, latest_triggered_webhooks_v3)
+  end
+
+  down do
+    create_or_replace_view(:latest_triggered_webhooks, latest_triggered_webhooks_v3_rollback(PactBroker::MigrationHelper.postgres?))
+  end
+end

data/db/migrations/migration_helper.rb

@@ -4,7 +4,7 @@ module PactBroker
     extend self
 
     def large_text_type
-      if adapter == 'postgres'
+      if postgres?
         :text
       else
         # Assume mysql
@@ -13,11 +13,19 @@ module PactBroker
     end
 
     def with_mysql
-      if adapter =~ /mysql/
+      if mysql?
         yield
       end
     end
 
+    def mysql?
+      adapter =~ /mysql/
+    end
+
+    def postgres?
+      adapter == 'postgres'
+    end
+
     def adapter
       Sequel::Model.db.adapter_scheme.to_s
     end

data/lib/pact_broker/api/decorators/decorator_context.rb

@@ -2,14 +2,14 @@ module PactBroker
   module Api
     module Decorators
       class DecoratorContext < Hash
-
-        attr_reader :base_url, :resource_url, :resource_title, :env
+        attr_reader :base_url, :resource_url, :resource_title, :env, :query_string
 
         def initialize base_url, resource_url, env, options = {}
           @base_url = self[:base_url] = base_url
           @resource_url = self[:resource_url] = resource_url
           @resource_title = self[:resource_title] = options[:resource_title]
           @env = self[:env] = env
+          @query_string = self[:query_string] = (env['QUERY_STRING'] && !env['QUERY_STRING'].empty? ? env['QUERY_STRING'] : nil)
           merge!(options)
         end
 

data/lib/pact_broker/api/decorators/pagination_links.rb

@@ -0,0 +1,34 @@
+require 'roar/decorator'
+require 'roar/json/hal'
+
+module PactBroker
+  module Api
+    module Decorators
+      module PaginationLinks
+        include Roar::JSON::HAL
+        include Roar::JSON::HAL::Links
+
+        link :next do | context |
+          if represented.respond_to?(:current_page) &&
+              represented.respond_to?(:page_count) &&
+              represented.current_page < represented.page_count
+            {
+              href: context[:resource_url] + "?pageSize=#{represented.page_size}&pageNumber=#{represented.current_page + 1}",
+              title: "Next page"
+            }
+
+          end
+        end
+
+        link :previous do | context |
+          if represented.respond_to?(:first_page?) && !represented.first_page?
+            {
+              href: context[:resource_url] + "?pageSize=#{represented.page_size}&pageNumber=#{represented.current_page - 1}",
+              title: "Previous page"
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/api/decorators/versions_decorator.rb

@@ -1,5 +1,6 @@
 require_relative 'base_decorator'
 require_relative 'version_decorator'
+require_relative 'pagination_links'
 
 module PactBroker
   module Api
@@ -9,12 +10,15 @@ module PactBroker
         collection :entries, as: :versions, embedded: true, :extend => PactBroker::Api::Decorators::VersionDecorator
 
         link :self do | context |
+          href = append_query_if_present(context[:resource_url], context[:query_string])
           {
-            href: context[:resource_url],
+            href: href,
             title: "All application versions of #{context[:pacticipant_name]}"
           }
         end
 
+        include PaginationLinks
+
         link :'pb:pacticipant' do | context |
           {
             href: pacticipant_url(context[:base_url], OpenStruct.new(name: context[:pacticipant_name])),

data/lib/pact_broker/api/pact_broker_urls.rb

@@ -307,6 +307,14 @@ module PactBroker
         ERB::Util.url_encode param
       end
 
+      def append_query_if_present(url, query)
+        if query && query.size > 0
+          url + "?#{query}"
+        else
+          url
+        end
+      end
+
       private
 
       def representable_pact pact

data/lib/pact_broker/api/resources/index.rb

@@ -144,7 +144,7 @@ module PactBroker
             }]
           }
 
-          if PactBroker.feature_enabled?(:disable_pacts_for_verification)
+          if PactBroker.feature_enabled?('disable_pacts_for_verification', true)
             links_hash.delete('pb:provider-pacts-for-verification')
             links_hash.delete('beta:provider-pacts-for-verification')
           end

data/lib/pact_broker/api/resources/provider_pacts_for_verification.rb

@@ -52,6 +52,7 @@ module PactBroker
         end
 
         def to_json
+          log_request
           PactBroker::Api::Decorators::VerifiablePactsDecorator.new(pacts).to_json(
             decorator_options(
               include_pending_status: parsed_query_params.include_pending_status,
@@ -76,12 +77,21 @@ module PactBroker
         def query
           @query ||= begin
             if request.get?
-              Rack::Utils.parse_nested_query(request.uri.query)
+              nested_query
             elsif request.post?
               params(symbolize_names: false, default: {})
             end
           end
         end
+
+        def log_request
+          parameters = request.get? ? nested_query : params
+          logger.info "Fetching pacts for verification by #{provider_name}", provider_name: provider_name, params: parameters
+        end
+
+        def nested_query
+          @nested_query ||= Rack::Utils.parse_nested_query(request.uri.query)
+        end
       end
     end
   end

data/lib/pact_broker/api/resources/versions.rb

@@ -23,12 +23,23 @@ module PactBroker
         end
 
         def versions
-          @versions ||= pacticipant_service.find_all_pacticipant_versions_in_reverse_order pacticipant_name
+          @versions ||= pacticipant_service.find_all_pacticipant_versions_in_reverse_order(pacticipant_name, pagination_options)
         end
 
         def policy_name
           :'versions::versions'
         end
+
+        def pagination_options
+          if request.query['pageNumber'] || request.query['pageSize']
+            {
+              page_number: request.query['pageNumber']&.to_i || 1,
+              page_size: request.query['pageSize']&.to_i || 100
+            }
+          else
+            nil
+          end
+        end
       end
     end
   end

data/lib/pact_broker/db/clean.rb

@@ -1,9 +1,20 @@
 require 'sequel'
 require 'pact_broker/project_root'
+require 'pact_broker/pacts/latest_tagged_pact_publications'
 
 module PactBroker
   module DB
     class Clean
+
+      class Unionable < Array
+        alias_method :union, :+
+
+        def union(other)
+          Unionable.new(self + other)
+        end
+      end
+
+
       def self.call database_connection, options = {}
         new(database_connection, options).call
       end
@@ -13,55 +24,87 @@ module PactBroker
         @options = options
       end
 
-      def call
-        deleted_counts = {}
-        kept_counts = {}
-        date = options[:date]
+      def keep
+        options[:keep] || [PactBroker::Matrix::UnresolvedSelector.new(tag: true, latest: true)]
+      end
 
-        version_ids_to_keep = nil
+      def resolve_ids(query)
+        # query
+        Unionable.new(query.collect { |h| h[:id] })
+      end
 
-        if options[:keep]
-          version_ids_to_keep = options[:keep].collect do | selector |
-            PactBroker::Domain::Version.select(:id).for_selector(selector)
-          end.reduce(&:union)
-        end
+      def pact_publication_ids_to_keep
+        @pact_publication_ids_to_keep ||= pact_publication_ids_to_keep_for_version_ids_to_keep
+                                            .union(pact_publications_to_keep_for_verification_ids_to_keep)
+                                            .union(latest_tagged_pact_publications_ids_to_keep)
+      end
 
-        pact_publication_ids_to_delete = if date
-          db[:pact_publications].select(:id).where(Sequel.lit('created_at < ?', date))
-        elsif version_ids_to_keep
-          db[:pact_publications].select(:id).where(consumer_version_id: version_ids_to_keep).invert
-        else
-          keep = db[:latest_tagged_pact_publications].select(:id).union(db[:latest_pact_publications].select(:id))
-          db[:pact_publications].select(:id).where(id: keep).invert
-        end
+      def pact_publication_ids_to_keep_for_version_ids_to_keep
+        @pact_publication_ids_to_keep_for_version_ids_to_keep ||= resolve_ids(db[:pact_publications].select(:id).where(consumer_version_id: version_ids_to_keep))
+      end
+
+      def pact_publications_to_keep_for_verification_ids_to_keep
+        @pact_publications_to_keep_for_verification_ids_to_keep ||= resolve_ids(db[:pact_publications].select(:id).where(pact_version_id: db[:verifications].select(:pact_version_id).where(id: verification_ids_to_keep_for_version_ids_to_keep)))
+      end
+
+      def latest_tagged_pact_publications_ids_to_keep
+        @latest_tagged_pact_publications_ids_to_keep ||= resolve_ids(keep.select(&:tag).select(&:latest).collect do | selector |
+          PactBroker::Pacts::LatestTaggedPactPublications.select(:id).for_selector(selector)
+        end.reduce(&:union))
+      end
+
+      def pact_publication_ids_to_delete
+        @pact_publication_ids_to_delete ||= resolve_ids(db[:pact_publications].select(:id).where(id: pact_publication_ids_to_keep).invert)
+      end
 
+      # because they belong to the versions to keep
+      def verification_ids_to_keep_for_version_ids_to_keep
+        @verification_ids_to_keep_for_version_ids_to_keep ||= resolve_ids(db[:verifications].select(:id).where(provider_version_id: version_ids_to_keep))
+      end
+
+      def verification_ids_to_keep_for_pact_publication_ids_to_keep
+        @verification_ids_to_keep_for_pact_publication_ids_to_keep ||= resolve_ids(db[:verifications].select(:id).where(pact_version_id: db[:pact_publications].select(:pact_version_id).where(id: pact_publication_ids_to_keep_for_version_ids_to_keep)))
+      end
+
+      def verification_ids_to_keep
+        @verification_ids_to_keep ||= verification_ids_to_keep_for_version_ids_to_keep.union(verification_ids_to_keep_for_pact_publication_ids_to_keep)
+      end
+
+      def verification_ids_to_delete
+        @verification_ids_to_delete ||= db[:verifications].select(:id).where(id: verification_ids_to_keep).invert
+      end
+
+      def version_ids_to_keep
+        @version_ids_to_keep ||= keep.collect do | selector |
+          PactBroker::Domain::Version.select(:id).for_selector(selector)
+        end.reduce(&:union)
+      end
+
+      def call
+        deleted_counts = {}
+        kept_counts = {}
 
         deleted_counts[:pact_publications] = pact_publication_ids_to_delete.count
-        kept_counts[:pact_publications] = db[:pact_publications].where(id: pact_publication_ids_to_delete).invert.count
+        kept_counts[:pact_publications] = pact_publication_ids_to_keep.count
 
-        # TODO head matrix is the head for the consumer tags, not the provider tags.
         # Work out how to keep the head verifications for the provider tags.
-        verification_ids = get_verification_ids(pact_publication_ids_to_delete)
-        deleted_counts[:verification_results] = verification_ids.count
-        kept_counts[:verification_results] = db[:verifications].where(id:verification_ids ).invert.count
 
-        delete_webhook_data(db[:triggered_webhooks].where(verification_id: verification_ids).select(:id))
-        verification_ids.delete
+        deleted_counts[:verification_results] = verification_ids_to_delete.count
+        kept_counts[:verification_results] = verification_ids_to_keep.count
 
-        delete_webhook_data(db[:triggered_webhooks].where(pact_publication_id: pact_publication_ids_to_delete).select(:id))
-        delete_pact_publications(pact_publication_ids_to_delete)
+        delete_webhook_data(verification_triggered_webhook_ids_to_delete)
+        delete_verifications
+
+        delete_webhook_data(pact_publication_triggered_webhook_ids_to_delete)
+        delete_pact_publications
 
         delete_orphan_pact_versions
         overwritten_delete_counts = delete_overwritten_verifications
         deleted_counts[:verification_results] = deleted_counts[:verification_results] + overwritten_delete_counts[:verification_results]
         kept_counts[:verification_results] = kept_counts[:verification_results] - overwritten_delete_counts[:verification_results]
 
-
-        referenced_version_ids = db[:pact_publications].select(:consumer_version_id).collect{ | h| h[:consumer_version_id] } +
-          db[:verifications].select(:provider_version_id).collect{ | h| h[:provider_version_id] }
-
-        delete_orphan_tags(referenced_version_ids)
-        delete_orphan_versions(referenced_version_ids)
+        delete_orphan_tags
+        delete_orphan_versions
 
         { kept: kept_counts, deleted: deleted_counts }
       end
@@ -70,8 +113,21 @@ module PactBroker
 
       attr_reader :db, :options
 
-      def get_verification_ids(pact_publication_ids)
-        db[:verifications].select(:id).where(pact_version_id: db[:pact_publications].select(:pact_version_id).where(id: pact_publication_ids))
+      def verification_triggered_webhook_ids_to_delete
+        db[:triggered_webhooks].select(:id).where(verification_id: verification_ids_to_delete)
+      end
+
+      def pact_publication_triggered_webhook_ids_to_delete
+        db[:triggered_webhooks].select(:id).where(pact_publication_id: pact_publication_ids_to_delete)
+      end
+
+      def referenced_version_ids
+        db[:pact_publications].select(:consumer_version_id).union(db[:verifications].select(:provider_version_id))
+      end
+
+      def verification_ids_for_pact_publication_ids_to_delete
+        @verification_ids_for_pact_publication_ids_to_delete ||=
+          db[:verifications].select(:id).where(pact_version_id: db[:pact_publications].select(:pact_version_id).where(id: pact_publication_ids_to_delete))
       end
 
       def delete_webhook_data(triggered_webhook_ids)
@@ -79,23 +135,24 @@ module PactBroker
         db[:triggered_webhooks].where(id: triggered_webhook_ids).delete
       end
 
-      def delete_pact_publications(pact_publication_ids)
-        db[:pact_publications].where(id: pact_publication_ids).delete
-        db[:pact_versions].where(id: db[:pact_publications].select(:pact_version_id)).invert.delete
+      def delete_pact_publications
+        db[:pact_publications].where(id: pact_publication_ids_to_delete).delete
+      end
+
+      def delete_verifications
+        db[:verifications].where(id: verification_ids_to_delete).delete
       end
 
       def delete_orphan_pact_versions
-        # TODO use union
-        referenced_pact_version_ids = db[:pact_publications].select(:pact_version_id).collect{ | h| h[:pact_version_id] } +
-          db[:verifications].select(:pact_version_id).collect{ | h| h[:pact_version_id] }
+        referenced_pact_version_ids = db[:pact_publications].select(:pact_version_id).union(db[:verifications].select(:pact_version_id))
         db[:pact_versions].where(id: referenced_pact_version_ids).invert.delete
       end
 
-      def delete_orphan_tags(referenced_version_ids)
+      def delete_orphan_tags
         db[:tags].where(version_id: referenced_version_ids).invert.delete
       end
 
-      def delete_orphan_versions(referenced_version_ids)
+      def delete_orphan_versions
         db[:versions].where(id: referenced_version_ids).invert.delete
       end