pact_broker 2.109.1 → 2.111.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4c49978b4312049fd2e394ce46bcf90f64125ff50556f9bb01f9610e1310546
-  data.tar.gz: 43f24ab98f5ce7bd757a52a085d653668d83395b6889921e8dc0d4aac5982b73
+  metadata.gz: e21e3c2fc82cfe4697582921613bd435e026cf6f381c64c33d703b8c31c586be
+  data.tar.gz: 6b6bc75a486f936441b172c7a80a7e8541f3bbb1731be03b1e33a869327014bf
 SHA512:
-  metadata.gz: 3211f2cc4b2e9fbae7dd8a07bd1c49dc9d672fa46f6f4c83b6652b2266dc9498d4858a9a7714f91b09914d872e522affc5e96753cf3317e39228fecc620404c1
-  data.tar.gz: 36a5bc3f3ecc827cd6e24fa21b4d4bc9f943ec75bfdb3db8cdcdd1399533739bf0a2c15c68df816ae995fa58987fa43d4da45dcb72a2d68fff12f7594a69906a
+  metadata.gz: 2afe779170a4910f06ace0a29b8ee66fa81bc355fc1a1c22a532fb3f9f64f5775309543c23b3b7ae4c4c837c1a66d0b10ddb0f62e8e9f586b7fd4942dc29d33c
+  data.tar.gz: 3b2738f3785dc1c272d4e1ba24104b4786bd467780808d41bdf2dd7f2ce0e83f0f11645a8ca3b8fd16642055a897d60b573ea7fc8392751cf0a59ecafeba6130

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+<a name="v2.111.0"></a>
+### v2.111.0 (2024-07-26)
+
+#### Features
+
+* add new label api (#703)	 ([ff3f84e2](/../../commit/ff3f84e2))
+* search pacticipants by display_name	 ([c5945801](/../../commit/c5945801))
+
+#### Bug Fixes
+
+* **docs**
+  * Update OAS with correct ref to Notice schema	 ([6729b7f8](/../../commit/6729b7f8))
+
+<a name="v2.110.0"></a>
+### v2.110.0 (2024-04-02)
+
+#### Features
+
+* reduce contention when updating the contract_data_updated_at field for integrations (#671)	 ([ff72d03c](/../../commit/ff72d03c))
+* support consumer version selector for all branches (#667)	 ([34334ca8](/../../commit/34334ca8))
+
+* **clean**
+  * use postgres advisory locks to ensure only one process can run a clean at a time (#672)	 ([637c25fa](/../../commit/637c25fa))
+
+#### Bug Fixes
+
+* use for_all_tag_heads instead of latest_by_consumer_tag when fetching wip by branch	 ([14148a34](/../../commit/14148a34))
+* optimise WIP pacts by using branch/tag heads (#668)	 ([871209e1](/../../commit/871209e1))
+* improve performance of WIP pacts by using branch heads instead of calculating latest pact for branch	 ([f9705583](/../../commit/f9705583))
+
 <a name="v2.109.1"></a>
 ### v2.109.1 (2024-02-21)
 

data/docs/developer/design_pattern_for_eager_loading_collections.md

@@ -0,0 +1,23 @@
+# Design pattern for eager loading collections
+
+For collection resources (eg. `/versions` ), associations included in the items (eg. branch versions) must be eager loaded for performance reasons.
+
+The responsiblities of each class used to render a collection resource are as follows:
+
+* collection decorator (eg. `VersionsDecorator`) - delegate each item in the collection to be rendered by the decorator for the individual item, render pagination links
+* item decorator (eg. `VersionDecorator`) - render the JSON for each item
+* resource (eg. `PactBroker::Api::Resources::Versions`) - coordinate between, and delegate to, the service and the decorator
+* service (eg. `PactBroker::Versions::Service`) - just delegate to repository, as there is no business logic required
+* repository (eg. `PactBroker::Versions::Repository`) - load the domain objects from the database
+
+If the associations for a model are not eager loaded, then each individual association will be lazy loaded when the decorator for the item calls the association method to render it. This results in at least `<number of items in the collection> * <number of associations to render>` calls to the database, and potentially more if any of the associations have their own associations that are required to render the item. This can cause significant performance issues.
+
+To efficiently render a collection resource, associations must be eager loaded when the collection items are loaded from the database in the repository. Since the repository method for loading the collection may be used in multiple places, and the eager loaded associations required for each of those places may be different (some may not require any associations to be eager loaded), we do not want to hard code the repository to load a fixed set of associations. The list of associations to eager load is therefore passed in to the repository finder method as an argument `eager_load_associations`.
+
+The decorator is the class that knows what associations are going to be called on the model to render the JSON, so following the design guideline of "put things together that change together", the best place for the declaration of "what associations should be eager loaded for this decorator" is in the decorator itself. The `PactBroker::Api::Decorators::BaseDecorator` has a default implementation of this method called `eager_load_associations` which attempts to automatically identify the required associations, but this can be overridden when necessary.
+
+We can therefore add the following responsiblities to our previous list:
+
+* item decorator - return a list of all the associations (including nested associations) that should be eager loaded in order to render its item
+* repository - eager load the associations that have been passed into it
+* resource - pass in the eager load associations to the repository from the decorator

data/docs/developer/matrix.md

@@ -0,0 +1,95 @@
+# The Matrix
+
+Read [these docs](https://docs.pact.io/pact_broker/advanced_topics/matrix_selectors) first for a introduction to matrix selectors and options from a user's perspective.
+
+## Terminology
+
+### Selectors
+
+#### Selector classes
+
+* `Unresolved selectors` - `PactBroker::Matrix::UnresolvedSelector` the class of the specified and ignore selectors, as they are created directly from the HTTP query. At this point, they are "unresolved" in that we do not know the IDs of the pacticipants/versions that they represent, and whether or not they even exist.
+
+* `Resolved selectors` - `PactBroker::Matrix::ResolvedSelector` the class of the object created for each selector, after its pacticipant and version IDs have been identified. If a selector represents multiple pacticipant versions (eg `{ branch: "main" }`) then one `ResolvedSelector` object will be returned for each pacticipant version found. The resolved selector keeps a reference to its original unresolved selector, as well as the pacticipant ID and the version ID. If the version or pacticipant specified does not actually exist, then a resolved selector is returned that indicates this.
+
+#### Selector collections
+
+* `Specified selectors` - the collection of objects that describe the application version(s) specified explicitly in the matrix query. eg. in `can-i-deploy --pacticipant Foo --version 1` the specified selector is `PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1")`. There may be multiple specified selectors, for example, in the Matrix page for an integration Foo/Bar, the specified selectors would be `[ UnresolvedSelector.new(pacticipant_name: "Foo"), UnresolvedSelector.new(pacticipant_name: "Bar")]`. The selectors may use various combinations of pacticipant name, version number, branch, tag or environment to identify the pacticipant versions.
+
+* `Ignore selectors` - the collection of objects that describe the applications (or application versions) to ignore, if there are any missing or failed verifications between the versions for the specified selectors and the ignore selectors. eg. If we know that provider Dog is not ready and the verifications are failing, but the integration is feature toggled off in the Foo code, we would use the command `can-i-deploy --pacticipant Foo --version 1 --to-environment production --ignore Dog` to allow `can-i-deploy` to pass. An ignore selector can have a version number, but it's more common to just provide the name.
+
+* `Inferred selectors` - the collection of objects that describe the application versions(s) that already exist in the target environment/with the target tag/on the target branches. These are identified during the matrix query when the `can-i-deploy` query has a `--to TAG`/`--to-environment`/`--with-main-branches` option specified, and they allow us to find the full set of matrix rows that tell us whether or the application version we're about to deploy is compatible with its integrated applications. For example, given Foo v1 is a consumer of Bar, and Bar v8 is in production, and the `can-i-deploy` command is `can-i-deploy --pacticipant Foo --version 1 --to-environment production`, then an inferred unresolved selector is created for Bar in the production environment (`UnresolvedSelector.new(pacticipant_name: "Bar", environment_name: "production")`) which is then resolved to Bar v8.
+
+#### Notes on selector classes/collections
+
+Specified, ignore, and inferred selectors all start life as `UnresolvedSelector` objects, which then get resolved into `ResolvedSelector` objects.
+
+### Options
+
+TBC.
+
+## How the matrix query works
+
+1. Given that Foo v1 is a consumer of Bar, and Bar v8 is currently in production, take the pact-broker CLI command `can-i-deploy --pacticipant Foo --version 1 --to-environment production --ignore Dog`
+
+1. Turn that into a query string and make a request to the `/matrix` endpoint.
+
+1. Parse the HTTP query into the specified selectors, the ignore selectors and options.
+
+  * specified selectors - `PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "Foo", pacticipant_version_number: "1")`
+  * ignore selectors - `PactBroker::Matrix::UnresolvedSelector.new(pacticipant_name: "Dog")`
+  * options: `{ to_environment: "production" }`
+
+1. Validate the selectors.
+
+  * Ensure conflicting fields are not used.
+  * Return an error if any of the pacticipants in the specified selectors or the environment do not exist.
+  * Do not check for the existance of version numbers or tags, or pacticipants in the ignore selectors.
+
+1. "Resolve" the ignore selectors (find the pacticipant and version IDs for the selectors).
+
+1. "Resolve" the specified selectors, passing in the ignore selectors to identify whether or not the resolved selector should be "ignored".
+
+1. Identify the integrations that the versions in the specified selectors are involved in.
+
+  * Identify the providers of the consumers: for the versions of each specified selector, find any pacts created for that version. If any exist, that means
+    the provider for each pact MUST be deployed to the target environment, and the deployed version must have a successful verification with the specified consumer version for the consumer to be safe to deploy. The providers must be identified for the specific consumer *version* of the selector, not just *consumer*, as different versions of a consumer may have different providers as integrations are created and removed over time. This is why we cannot just query the integrations table.
+
+    Represent the integration by creating a `PactBroker::Matrix::Integration` object for each consumer/provider pair, and mark it as `required: true`.
+
+  * Identify the consumers of the providers: for the pacticipant of each specified selector, find any integrations in the integrations table where
+    the specified pacticipant is the provider. Because specific provider versions don't have a dependency on any specific consumer versions being already present in an environment, we do not need to run this query at the pacticipant version level - we can just check the presence of any consumers at the integration level.
+
+    Represent the integration by creating a `PactBroker::Matrix::Integration` object for each consumer/provider pair, and mark it as `required: false`.
+
+1. Identify the inferred unresolved selectors (the selectors for the pacticipant versions that are already in the target scope)
+
+  * Collect all the pacticipant names from the integrations identified in the previous step. For every pacticipant name that does NOT already have a specified selector, create a new unresolved "inferred" selector for that pacticipant, and set the version selection attributes to be the target scope from the original `can-i-deploy` query. eg. Given we have identifed the required `Integration` for consumer Foo and provider Bar, and we are determining if we can deploy Foo to production, create an unresolved selector for Bar in the production environment (`UnresolvedSelector.new(pacticipant_name: "Bar", environment_name: "production"`).
+
+1. "Resolve" the inferred selectors (find the pacticipant and version IDs).
+
+1. Add the specified and inferred resolved selectors together to make the final collection of selectors that will be used to query the matrix.
+
+1. Peform the matrix query.
+
+  * When there are 2 or more total resolved selectors (the usual usecase):
+
+    * Create a collection of all the pacticipants in the selectors (let's call it `all_pacticipants_in_selectors`).
+
+    * Create the pact/consumer version dataset
+
+      * For each selector, find the pact publications where the consumer version is one of the versions described by the selector, and the provider is one of `all_pacticipants_in_selectors`.
+
+    * Create the verification/provider version dataset.
+
+      * For each selector, find the verifications where the provider version is one of the versions described by the selector, and the consumer is one of `all_pacticipants_in_selectors`.
+
+    * Join the pact/consumer verison dataset to the verification/provider version dataset.
+
+      * The two datasets are joined on the `pact_version_id` - this is the ID of the unique pact content that every pact publication and provider verification has a reference to. A left outer join is used, so that if there is a pact that doesn't have a verification, a row is present for the pact, with empty provider version columns. This allows us to identify that there is a missing verification.
+
+
+  * When there is only 1 total resolved selector: this is an unusual usecase, and cannot be done via the UI or the CLI, so I'm not going to spend time documenting it. Just know it is supported and theoretically possible.
+
+
+

data/docs/developer/rack.md

@@ -0,0 +1,11 @@
+# Rack
+
+https://medium.com/quick-code/rack-middleware-vs-rack-application-vs-rack-the-gem-vs-rack-the-architecture-912cd583ed24
+https://github.com/rack/rack/blob/main/SPEC.rdoc
+https://www.rubyguides.com/2018/09/rack-middleware/
+
+
+* Responds to `call`
+* Accepts a hash of parameters
+* Returns an array where the first item is the http status, the second is a hash of headers, and the third is an object that responds to `each` (or `call`) that provides the body (99% of the time it's an array of length 1 with a string)
+

data/lib/pact_broker/api/contracts/consumer_version_selector_contract.rb

@@ -13,7 +13,7 @@ module PactBroker
         json do
           optional(:mainBranch).filled(included_in?: [true])
           optional(:tag).filled(:str?)
-          optional(:branch).filled(:str?)
+          optional(:branch).filled { str? | eql?(true) }
           optional(:matchingBranch).filled(included_in?: [true])
           optional(:latest).filled(included_in?: [true, false])
           optional(:fallbackTag).filled(:str?)

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

@@ -34,7 +34,16 @@ module PactBroker
           end
         end
 
-        # Returns the names of the model associations to eager load for use with this decorator
+        # Returns the names of the model associations to eager load for use with this decorator.
+        # The default implementation attempts to do an "auto detect" of the associations.
+        # For single item decorators, it attempts to identify the attributes that are themselves models.
+        # For collection decorators, it delegates to the eager_load_associations
+        # method of the single item decorator used to decorate the collection.
+        #
+        # The "auto detect" logic can only go so far. It cannot identify when a child object needs its own
+        # child object(s) to render the attribute.
+        # This method should be overridden when the "auto detect" logic cannot identify the correct associations
+        # to load. eg VersionDecorator
         # @return [Array<Symbol>]
         def self.eager_load_associations
           if is_collection_resource?

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

@@ -11,20 +11,26 @@ module PactBroker
 
         include Timestamps
 
-        link :self do | options |
-          {
-            title: "Label",
-            name: represented.name,
-            href: label_url(represented, options[:base_url])
-          }
-        end
+        # This method is overridden to conditionally render the links based on the user_options
+        def to_hash(options)
+          hash = super
+
+          unless options.dig(:user_options, :hide_label_decorator_links)
+            hash[:_links] = {
+              self: {
+                title: "Label",
+                name: represented.name,
+                href: label_url(represented, options.dig(:user_options, :base_url))
+              },
+              pacticipant: {
+                title: "Pacticipant",
+                name: represented.pacticipant.name,
+                href: pacticipant_url(options.dig(:user_options, :base_url), represented.pacticipant)
+              }
+            }
+          end
 
-        link :pacticipant do | options |
-          {
-            title: "Pacticipant",
-            name: represented.pacticipant.name,
-            href: pacticipant_url(options.fetch(:base_url), represented.pacticipant)
-          }
+          hash
         end
       end
     end

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

@@ -0,0 +1,23 @@
+require_relative "base_decorator"
+require_relative "pagination_links"
+require_relative "label_decorator"
+require "pact_broker/domain/label"
+
+module PactBroker
+  module Api
+    module Decorators
+      class LabelsDecorator < BaseDecorator
+        collection :entries, :as => :labels, :class => PactBroker::Domain::Label, :extend => PactBroker::Api::Decorators::LabelDecorator, embedded: true
+
+        include PaginationLinks
+
+        link :self do | options |
+          {
+            title: "Labels",
+            href: options.fetch(:resource_url)
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -20,7 +20,7 @@ module PactBroker
         property :main_branch
 
         property :latest_version, as: :latestVersion, :class => PactBroker::Domain::Version, extend: PactBroker::Api::Decorators::EmbeddedVersionDecorator, embedded: true, writeable: false
-        collection :labels, :class => PactBroker::Domain::Label, extend: PactBroker::Api::Decorators::EmbeddedLabelDecorator, embedded: true
+        collection :labels, :class => PactBroker::Domain::Label, extend: PactBroker::Api::Decorators::EmbeddedLabelDecorator, embedded: true, writeable: false
 
         include Timestamps
 

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

@@ -17,6 +17,20 @@ module PactBroker
 
         include Timestamps
 
+        # Returns the list of associations that must be eager loaded to efficiently render a version
+        # when this decorator is used in a collection (eg. VersionsDecorator)
+        # The associations that need to be eager loaded for the VersionDecorator
+        # are hand coded
+        # @return <Array>
+        def self.eager_load_associations
+          [
+            :pacticipant,
+            :pact_publications,
+            { branch_versions: [:version, :branch_head, { branch: :pacticipant }] },
+            { tags: :head_tag }
+          ]
+        end
+
         link :self do | options |
           {
             title: "Version",

data/lib/pact_broker/api/paths.rb

@@ -3,11 +3,12 @@ module PactBroker
     module Paths
       PACT_BADGE_PATH =         %r{^/pacts/provider/[^/]+/consumer/.*/badge(?:\.[A-Za-z]+)?$}.freeze
       MATRIX_BADGE_PATH =       %r{^/matrix/provider/[^/]+/latest/[^/]+/consumer/[^/]+/latest/[^/]+/badge(?:\.[A-Za-z]+)?$}.freeze
+      CAN_I_MERGE_BADGE_PATH = %r{^/pacticipants/[^/]+/main-branch/can-i-merge/badge(?:\.[A-Za-z]+)?$}.freeze
       CAN_I_DEPLOY_TAG_BADGE_PATH = %r{^/pacticipants/[^/]+/latest-version/[^/]+/can-i-deploy/to/[^/]+/badge(?:\.[A-Za-z]+)?$}.freeze
       CAN_I_DEPLOY_BRANCH_ENV_BADGE_PATH = %r{^/pacticipants/[^/]+/branches/[^/]+/latest-version/can-i-deploy/to-environment/[^/]+/badge(?:\.[A-Za-z]+)?$}.freeze
       VERIFICATION_RESULTS =    %r{^/pacts/provider/[^/]+/consumer/[^/]+/pact-version/[^/]+/verification-results/[^/]+}
 
-      BADGE_PATHS = [PACT_BADGE_PATH, MATRIX_BADGE_PATH, CAN_I_DEPLOY_TAG_BADGE_PATH, CAN_I_DEPLOY_BRANCH_ENV_BADGE_PATH]
+      BADGE_PATHS = [PACT_BADGE_PATH, MATRIX_BADGE_PATH, CAN_I_DEPLOY_TAG_BADGE_PATH, CAN_I_DEPLOY_BRANCH_ENV_BADGE_PATH, CAN_I_MERGE_BADGE_PATH]
 
       extend self
 

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

@@ -31,7 +31,7 @@ module PactBroker
         end
 
         def versions
-          @versions ||= version_service.find_pacticipant_versions_in_reverse_order(pacticipant_name, { branch_name: identifier_from_path[:branch_name] }, pagination_options)
+          @versions ||= version_service.find_pacticipant_versions_in_reverse_order(pacticipant_name, { branch_name: identifier_from_path[:branch_name] }, pagination_options, decorator_class(:versions_decorator).eager_load_associations)
         end
 
         def policy_name

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

@@ -0,0 +1,36 @@
+require "pact_broker/api/resources/base_resource"
+require "pact_broker/api/resources/badge_methods"
+
+module PactBroker
+  module Api
+    module Resources
+      class CanIMergeBadge < BaseResource
+        include BadgeMethods # This module contains all necessary webmachine methods for badge implementation
+
+        def badge_url 
+          if pacticipant.nil? # pacticipant method is defined in BaseResource
+            # if the pacticipant is nil, we return an error badge url
+            badge_service.error_badge_url("pacticipant", "not found")
+          elsif version.nil?
+            # when there is no main branch version, we return an error badge url
+            badge_service.error_badge_url("main branch version", "not found")
+          else
+            # we call badge_service to build the badge url
+            badge_service.can_i_merge_badge_url(deployable: results)
+          end
+        end
+        
+        private
+
+        def results
+          # can_i_merge returns true or false if the main branch version is compatible with all the integrations
+          @results ||= matrix_service.can_i_merge(pacticipant: pacticipant, latest_main_branch_version: version)
+        end
+
+        def version
+          @version ||= version_service.find_latest_version_from_main_branch(pacticipant) 
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require "pact_broker/api/resources/base_resource"
+require "pact_broker/api/decorators/labels_decorator"
+require "pact_broker/api/resources/pagination_methods"
+
+module PactBroker
+  module Api
+    module Resources
+      class Labels < BaseResource
+        include PaginationMethods
+
+        def content_types_provided
+          [["application/hal+json", :to_json]]
+        end
+
+        def allowed_methods
+          ["GET", "OPTIONS"]
+        end
+
+        def policy_name
+          :'labels::labels'
+        end
+
+        def to_json
+          decorator_class(:labels_decorator).new(labels).to_json(
+            **decorator_options(
+              hide_label_decorator_links: true,
+            )
+          )
+        end
+
+        def labels
+          label_service.get_all_unique_labels(pagination_options)
+        end
+      end
+    end
+  end
+end

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

@@ -15,6 +15,10 @@ module PactBroker
           [["application/hal+json", :to_json]]
         end
 
+        # TODO drop support for GET in next major version.
+        # GET was only used by the very first Ruby Pact clients that supported the 'pacts for verification'
+        # feature, until it became clear that the parameters for the request were going to get nested and complex,
+        # at which point the POST was added.
         def allowed_methods
           ["GET", "POST", "OPTIONS"]
         end
@@ -32,6 +36,7 @@ module PactBroker
           end
         end
 
+        # For this endoint, the POST is a "read" action (used for Pactflow)
         def read_methods
           super + %w{POST}
         end

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

@@ -31,7 +31,7 @@ module PactBroker
         end
 
         def versions
-          @versions ||= version_service.find_all_pacticipant_versions_in_reverse_order(pacticipant_name, pagination_options)
+          @versions ||= version_service.find_pacticipant_versions_in_reverse_order(pacticipant_name, {}, pagination_options, decorator_class(:versions_decorator).eager_load_associations)
         end
 
         def policy_name

data/lib/pact_broker/api.rb

@@ -85,6 +85,9 @@ module PactBroker
         add ["pacticipants", :pacticipant_name], Api::Resources::Pacticipant, {resource_name: "pacticipant"}
         add ["pacticipants", :pacticipant_name, "labels", :label_name], Api::Resources::Label, {resource_name: "pacticipant_label"}
 
+        # Labels
+        add ["labels"], Api::Resources::Labels, {resource_name: "labels"}
+
         # Versions
         add ["pacticipants", :pacticipant_name, "versions"], Api::Resources::Versions, {resource_name: "pacticipant_versions"}
         add ["pacticipants", :pacticipant_name, "branches", :branch_name, "versions"], Api::Resources::BranchVersions, {resource_name: "pacticipant_branch_versions"}
@@ -92,6 +95,7 @@ module PactBroker
         add ["pacticipants", :pacticipant_name, "latest-version", :tag], Api::Resources::LatestVersion, {resource_name: "latest_tagged_pacticipant_version"}
         add ["pacticipants", :pacticipant_name, "latest-version", :tag, "can-i-deploy", "to", :to], Api::Resources::CanIDeployPacticipantVersionByTagToTag, { resource_name: "can_i_deploy_latest_tagged_version_to_tag" }
         add ["pacticipants", :pacticipant_name, "latest-version", :tag, "can-i-deploy", "to", :to, "badge"], Api::Resources::CanIDeployPacticipantVersionByTagToTagBadge, { resource_name: "can_i_deploy_latest_tagged_version_to_tag_badge" }
+        add ["pacticipants", :pacticipant_name, "main-branch", "can-i-merge", "badge"], Api::Resources::CanIMergeBadge, { resource_name: "can_i_merge_badge" }
         add ["pacticipants", :pacticipant_name, "latest-version"], Api::Resources::LatestVersion, {resource_name: "latest_pacticipant_version"}
         add ["pacticipants", :pacticipant_name, "versions", :pacticipant_version_number, "tags", :tag_name], Api::Resources::Tag, {resource_name: "pacticipant_version_tag"}
         add ["pacticipants", :pacticipant_name, "branches"], Api::Resources::PacticipantBranches, {resource_name: "pacticipant_branches"}

data/lib/pact_broker/app.rb

@@ -27,6 +27,7 @@ require "pact_broker/config/basic_auth_configuration"
 require "pact_broker/api/authorization/resource_access_policy"
 require "pact_broker/api/middleware/http_debug_logs"
 require "pact_broker/application_context"
+require "pact_broker/db/advisory_lock"
 
 module PactBroker
 
@@ -101,22 +102,19 @@ module PactBroker
 
     def prepare_database
       logger.info "Database schema version is #{PactBroker::DB.version(configuration.database_connection)}"
+      lock = PactBroker::DB::AdvisoryLock.new(configuration.database_connection, :migrate, :pg_advisory_lock)
       if configuration.auto_migrate_db
-        migration_options = { allow_missing_migration_files: configuration.allow_missing_migration_files }
-        if PactBroker::DB.is_current?(configuration.database_connection, migration_options)
-          logger.info "Skipping database migrations as the latest migration has already been applied"
-        else
-          logger.info "Migrating database schema"
-          PactBroker::DB.run_migrations configuration.database_connection, migration_options
-          logger.info "Database schema version is now #{PactBroker::DB.version(configuration.database_connection)}"
+        lock.with_lock do
+          ensure_all_database_migrations_are_applied
         end
       else
         logger.info "Skipping database schema migrations as database auto migrate is disabled"
       end
 
       if configuration.auto_migrate_db_data
-        logger.info "Migrating data"
-        PactBroker::DB.run_data_migrations configuration.database_connection
+        lock.with_lock do
+          run_data_migrations
+        end
       else
         logger.info "Skipping data migrations"
       end
@@ -125,6 +123,23 @@ module PactBroker
       PactBroker::Webhooks::Service.fail_retrying_triggered_webhooks
     end
 
+    def ensure_all_database_migrations_are_applied
+      migration_options = { allow_missing_migration_files: configuration.allow_missing_migration_files }
+
+      if PactBroker::DB.is_current?(configuration.database_connection, migration_options)
+        logger.info "Skipping database migrations as the latest migration has already been applied"
+      else
+        logger.info "Migrating database schema"
+        PactBroker::DB.run_migrations(configuration.database_connection, migration_options)
+        logger.info "Database schema version is now #{PactBroker::DB.version(configuration.database_connection)}"
+      end
+    end
+
+    def run_data_migrations
+      logger.info "Migrating data"
+      PactBroker::DB.run_data_migrations(configuration.database_connection)
+    end
+
     def load_configuration_from_database
       configuration.load_from_database!
     end

data/lib/pact_broker/badges/service.rb

@@ -40,6 +40,24 @@ module PactBroker
         build_shield_io_uri(title, status, color)
       end
 
+      def can_i_merge_badge_url(deployable: nil)
+        title = "can-i-merge"
+        
+        # rubocop:disable Layout/EndAlignment
+        color, status = case deployable
+        when nil
+          [ "lightgrey", "unknown" ]
+        when true
+          [ "brightgreen", "success" ]
+        else
+          [ "red", "failed" ]
+        end
+        # rubocop:enable Layout/EndAlignment
+
+        # left text is "can-i-merge", right text is the version number
+        build_shield_io_uri(title, status, color)
+      end
+
       def error_badge_url(left_text, right_text)
         build_shield_io_uri(left_text, right_text, "lightgrey")
       end

data/lib/pact_broker/contracts/service.rb

@@ -35,7 +35,7 @@ module PactBroker
         version, version_notices = create_version(parsed_contracts)
         tags = create_tags(parsed_contracts, version)
         pacts, pact_notices = create_pacts(parsed_contracts, base_url)
-        update_integrations(pacts)
+        create_or_update_integrations(pacts)
         notices = version_notices + pact_notices
         ContractsPublicationResults.from_hash(
           pacticipant: version.pacticipant,
@@ -304,7 +304,11 @@ module PactBroker
         PactBroker::Api::PactBrokerUrls.triggered_webhook_logs_url(triggered_webhook, base_url)
       end
 
-      def update_integrations(pacts)
+      # Creating/updating the integrations all at once at the end of the transaction instead
+      # of one by one, as each pact is created, reduces the amount of time that
+      # a lock is held on the integrations table, therefore reducing contention
+      # and potential for deadlocks when there are many pacts being published at once.
+      def create_or_update_integrations(pacts)
         integration_service.handle_bulk_contract_data_published(pacts)
       end
 

data/lib/pact_broker/db/advisory_lock.rb

@@ -0,0 +1,58 @@
+require "pact_broker/logging"
+
+# Uses a Postgres advisory lock to ensure that a given block of code can only have ONE
+# thread in excution at a time against a given database.
+# When the database is not Postgres, the block will yield without any locks, allowing
+# this class to be used safely with other database types, but without the locking
+# functionality.
+#
+# This is a wrapper around the actual implementation code in the Sequel extension from https://github.com/yuryroot/sequel-pg_advisory_lock
+# which was copied into this codebase and modified for usage in this codebase.
+#
+# See https://www.postgresql.org/docs/16/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS for docs on lock types
+#
+
+module PactBroker
+  module DB
+    class AdvisoryLock
+      include PactBroker::Logging
+
+      def initialize(database_connection, name, type = :pg_try_advisory_lock)
+        @database_connection = database_connection
+        @name = name
+        @type = type
+        @lock_obtained = false
+        register_advisory_lock if postgres?
+      end
+
+      def with_lock
+        if postgres?
+          @database_connection.with_advisory_lock(@name) do
+            logger.debug("Lock #{@name} obtained")
+            @lock_obtained = true
+            yield
+          end
+        else
+          logger.warn("Executing block without lock as this is not a Postgres database")
+          @lock_obtained = true
+          yield
+        end
+      end
+
+      def lock_obtained?
+        @lock_obtained
+      end
+
+      private
+
+      def postgres?
+        @database_connection.adapter_scheme.to_s =~ /postgres/
+      end
+
+      def register_advisory_lock
+        @database_connection.extension :pg_advisory_lock
+        @database_connection.register_advisory_lock(@name, @type)
+      end
+    end
+  end
+end

data/lib/pact_broker/domain/version.rb

@@ -4,9 +4,10 @@ require "pact_broker/versions/eager_loaders"
 
 module PactBroker
   module Domain
-    VERSION_COLUMNS = [:id, :number, :repository_ref, :pacticipant_id, :order, :created_at, :updated_at, :build_url]
+    class Version < Sequel::Model
+      VERSION_COLUMNS = Sequel::Model.db.schema(:versions).collect(&:first) - [:branch] # do not include the branch column, as we now have a branches table
+      set_dataset(Sequel::Model.db[:versions].select(*VERSION_COLUMNS.collect{ | column | Sequel.qualify(:versions, column) }))
 
-    class Version < Sequel::Model(Sequel::Model.db[:versions].select(*VERSION_COLUMNS.collect{ | column | Sequel.qualify(:versions, column) }))
       set_primary_key :id
 
       plugin :timestamps, update_on_create: true