statesman 7.1.0 → 7.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d3c4334aeb972468799292be667b537dddf997d9fe065521cfe9454ed938b2a7
-  data.tar.gz: d78b8accf1d41e1da296d4e815c660df4889320bd2d40e85ee680061e9c2d947
+  metadata.gz: 421da0e6d201060df4733a0e52e2742df2b1d527f241873dfd4b820c74cc587f
+  data.tar.gz: 20cd64e291373c21b83886cfdc12c7e68450759515557f3853bfc68bfff8ed38
 SHA512:
-  metadata.gz: 582292d37d4cd51742ad15894a2c1fe0b93894d1337d9631ecc7fd4ca0f6ff7e33c0ce9889729cad4d10490def304b4336ea843121bb751d89256ef0b034c647
-  data.tar.gz: 129e07afb181e19af2b89443740449b799616aaacf07e4bf3224417ae3c97cae376ba923ac979c2ada15111d54f844036e3e0ea8b9e7870e0300258736138e2a
+  metadata.gz: c48d5415915aee8e4f595b78b9018b9a048bfb3d8e3ff33a3efce0ba962540f71af1fe982a389d5b51104c8284fc485f4bfa62390a3c92f03fa7ce4592a2ffbf
+  data.tar.gz: cf11b1793461381b835efe9b2343b54c348a01de85fc0cbd63623a0c18cf21f9935f6cb4251d9117a7d73b52df7041458a943d160628073afc96eb5c16237d73

data/.circleci/config.yml

@@ -56,6 +56,7 @@ jobs:
         environment:
           - POSTGRES_USER=postgres
           - POSTGRES_DB=statesman_test
+          - POSTGRES_PASSWORD=statesman
     steps: *steps
 
   build-ruby265-rails-602-mysql:
@@ -83,6 +84,7 @@ jobs:
         environment:
           - POSTGRES_USER=postgres
           - POSTGRES_DB=statesman_test
+          - POSTGRES_PASSWORD=statesman
     steps: *steps
   build-ruby265-rails-master-mysql:
     docker:
@@ -110,6 +112,7 @@ jobs:
         environment:
           - POSTGRES_USER=postgres
           - POSTGRES_DB=statesman_test
+          - POSTGRES_PASSWORD=statesman
     steps: *steps
 
   build-ruby270-rails-602-mysql:
@@ -137,6 +140,7 @@ jobs:
         environment:
           - POSTGRES_USER=postgres
           - POSTGRES_DB=statesman_test
+          - POSTGRES_PASSWORD=statesman
     steps: *steps
   build-ruby270-rails-master-mysql:
     docker:
@@ -164,6 +168,7 @@ jobs:
         environment:
           - POSTGRES_USER=postgres
           - POSTGRES_DB=statesman_test
+          - POSTGRES_PASSWORD=statesman
     steps: *steps
 
 workflows:

data/lib/statesman.rb

@@ -20,14 +20,25 @@ module Statesman
   # Example:
   #   Statesman.configure do
   #     storage_adapter Statesman::ActiveRecordAdapter
+  #     enable_mysql_gaplock_protection
   #   end
   #
   def self.configure(&block)
-    config = Config.new(block)
+    @config = Config.new(block)
     @storage_adapter = config.adapter_class
   end
 
   def self.storage_adapter
     @storage_adapter || Adapters::Memory
   end
+
+  def self.mysql_gaplock_protection?
+    return @mysql_gaplock_protection unless @mysql_gaplock_protection.nil?
+
+    @mysql_gaplock_protection = config.mysql_gaplock_protection?
+  end
+
+  def self.config
+    @config ||= Config.new
+  end
 end

data/lib/statesman/adapters/active_record.rb

@@ -5,9 +5,6 @@ require_relative "../exceptions"
 module Statesman
   module Adapters
     class ActiveRecord
-      attr_reader :transition_class
-      attr_reader :parent_model
-
       JSON_COLUMN_TYPES = %w[json jsonb].freeze
 
       def self.database_supports_partial_indexes?
@@ -19,6 +16,10 @@ module Statesman
         end
       end
 
+      def self.adapter_name
+        ::ActiveRecord::Base.connection.adapter_name.downcase
+      end
+
       def initialize(transition_class, parent_model, observer, options = {})
         serialized = serialized?(transition_class)
         column_type = transition_class.columns_hash["metadata"].sql_type
@@ -29,12 +30,15 @@ module Statesman
         end
 
         @transition_class = transition_class
+        @transition_table = transition_class.arel_table
         @parent_model = parent_model
         @observer = observer
         @association_name =
           options[:association_name] || @transition_class.table_name
       end
 
+      attr_reader :transition_class, :transition_table, :parent_model
+
       def create(from, to, metadata = {})
         create_transition(from.to_s, to.to_s, metadata)
       rescue ::ActiveRecord::RecordNotUnique => e
@@ -65,19 +69,36 @@ module Statesman
 
       private
 
+      # rubocop:disable Metrics/MethodLength
       def create_transition(from, to, metadata)
-        transition_attributes = { to_state: to,
-                                  sort_key: next_sort_key,
-                                  metadata: metadata }
-
-        transition_attributes[:most_recent] = true
-
-        transition = transitions_for_parent.build(transition_attributes)
+        transition = transitions_for_parent.build(
+          default_transition_attributes(to, metadata),
+        )
 
         ::ActiveRecord::Base.transaction(requires_new: true) do
           @observer.execute(:before, from, to, transition)
-          unset_old_most_recent
-          transition.save!
+
+          if mysql_gaplock_protection?
+            # We save the transition first with most_recent falsy, then mark most_recent
+            # true after to avoid letting MySQL acquire a next-key lock which can cause
+            # deadlocks.
+            #
+            # To avoid an additional query, we manually adjust the most_recent attribute
+            # on our transition assuming that update_most_recents will have set it to true
+
+            transition.save!
+
+            unless update_most_recents(transition.id).positive?
+              raise ActiveRecord::Rollback, "failed to update most_recent"
+            end
+
+            transition.assign_attributes(most_recent: true)
+          else
+            update_most_recents
+            transition.assign_attributes(most_recent: true)
+            transition.save!
+          end
+
           @last_transition = transition
           @observer.execute(:after, from, to, transition)
           add_after_commit_callback(from, to, transition)
@@ -85,6 +106,16 @@ module Statesman
 
         transition
       end
+      # rubocop:enable Metrics/MethodLength
+
+      def default_transition_attributes(to, metadata)
+        {
+          to_state: to,
+          sort_key: next_sort_key,
+          metadata: metadata,
+          most_recent: not_most_recent_value,
+        }
+      end
 
       def add_after_commit_callback(from, to, transition)
         ::ActiveRecord::Base.connection.add_transaction_record(
@@ -98,20 +129,92 @@ module Statesman
         parent_model.send(@association_name)
       end
 
-      def unset_old_most_recent
-        most_recent = transitions_for_parent.where(most_recent: true)
+      # Sets the given transition most_recent = t while unsetting the most_recent of any
+      # previous transitions.
+      def update_most_recents(most_recent_id = nil)
+        update = build_arel_manager(::Arel::UpdateManager)
+        update.table(transition_table)
+        update.where(most_recent_transitions(most_recent_id))
+        update.set(build_most_recents_update_all_values(most_recent_id))
 
-        # Check whether the `most_recent` column allows null values. If it
-        # doesn't, set old records to `false`, otherwise, set them to `NULL`.
-        #
-        # Some conditioning here is required to support databases that don't
-        # support partial indexes. By doing the conditioning on the column,
-        # rather than Rails' opinion of whether the database supports partial
-        # indexes, we're robust to DBs later adding support for partial indexes.
-        if transition_class.columns_hash["most_recent"].null == false
-          most_recent.update_all(with_updated_timestamp(most_recent: false))
+        # MySQL will validate index constraints across the intermediate result of an
+        # update. This means we must order our update to deactivate the previous
+        # most_recent before setting the new row to be true.
+        update.order(transition_table[:most_recent].desc) if mysql_gaplock_protection?
+
+        ::ActiveRecord::Base.connection.update(update.to_sql)
+      end
+
+      def most_recent_transitions(most_recent_id = nil)
+        if most_recent_id
+          transitions_of_parent.and(
+            transition_table[:id].eq(most_recent_id).or(
+              transition_table[:most_recent].eq(true),
+            ),
+          )
+        else
+          transitions_of_parent.and(transition_table[:most_recent].eq(true))
+        end
+      end
+
+      def transitions_of_parent
+        transition_table[parent_join_foreign_key.to_sym].eq(parent_model.id)
+      end
+
+      # Generates update_all Arel values that will touch the updated timestamp (if valid
+      # for this model) and set most_recent to true only for the transition with a
+      # matching most_recent ID.
+      #
+      # This is quite nasty, but combines two updates (set all most_recent = f, set
+      # current most_recent = t) into one, which helps improve transition performance
+      # especially when database latency is significant.
+      #
+      # The SQL this can help produce looks like:
+      #
+      #   update transitions
+      #      set most_recent = (case when id = 'PA123' then TRUE else FALSE end)
+      #        , updated_at = '...'
+      #      ...
+      #
+      def build_most_recents_update_all_values(most_recent_id = nil)
+        [
+          [
+            transition_table[:most_recent],
+            Arel::Nodes::SqlLiteral.new(most_recent_value(most_recent_id)),
+          ],
+        ].tap do |values|
+          # Only if we support the updated at timestamps should we add this column to the
+          # update
+          updated_column, updated_at = updated_column_and_timestamp
+
+          if updated_column
+            values << [
+              transition_table[updated_column.to_sym],
+              updated_at,
+            ]
+          end
+        end
+      end
+
+      def most_recent_value(most_recent_id)
+        if most_recent_id
+          Arel::Nodes::Case.new.
+            when(transition_table[:id].eq(most_recent_id)).then(db_true).
+            else(not_most_recent_value).to_sql
+        else
+          Arel::Nodes::SqlLiteral.new(not_most_recent_value)
+        end
+      end
+
+      # Provide a wrapper for constructing an update manager which handles a breaking API
+      # change in Arel as we move into Rails >6.0.
+      #
+      # https://github.com/rails/rails/commit/7508284800f67b4611c767bff9eae7045674b66f
+      def build_arel_manager(manager)
+        if manager.instance_method(:initialize).arity.zero?
+          manager.new
         else
-          most_recent.update_all(with_updated_timestamp(most_recent: nil))
+          manager.new(::ActiveRecord::Base)
         end
       end
 
@@ -170,7 +273,8 @@ module Statesman
         end
       end
 
-      def with_updated_timestamp(params)
+      # updated_column_and_timestamp should return [column_name, value]
+      def updated_column_and_timestamp
         # TODO: Once we've set expectations that transition classes should conform to
         # the interface of Adapters::ActiveRecordTransition as a breaking change in the
         # next major version, we can stop calling `#respond_to?` first and instead
@@ -184,15 +288,45 @@ module Statesman
                    ActiveRecordTransition::DEFAULT_UPDATED_TIMESTAMP_COLUMN
                  end
 
-        return params if column.nil?
+        # No updated timestamp column, don't return anything
+        return nil if column.nil?
 
-        timestamp = if ::ActiveRecord::Base.default_timezone == :utc
-                      Time.now.utc
-                    else
-                      Time.now
-                    end
+        [
+          column, ::ActiveRecord::Base.default_timezone == :utc ? Time.now.utc : Time.now
+        ]
+      end
+
+      def mysql_gaplock_protection?
+        Statesman.mysql_gaplock_protection?
+      end
+
+      def db_true
+        value = ::ActiveRecord::Base.connection.type_cast(
+          true,
+          transition_class.columns_hash["most_recent"],
+        )
+        ::ActiveRecord::Base.connection.quote(value)
+      end
+
+      def db_false
+        value = ::ActiveRecord::Base.connection.type_cast(
+          false,
+          transition_class.columns_hash["most_recent"],
+        )
+        ::ActiveRecord::Base.connection.quote(value)
+      end
 
-        params.merge(column => timestamp)
+      # Check whether the `most_recent` column allows null values. If it doesn't, set old
+      # records to `false`, otherwise, set them to `NULL`.
+      #
+      # Some conditioning here is required to support databases that don't support partial
+      # indexes. By doing the conditioning on the column, rather than Rails' opinion of
+      # whether the database supports partial indexes, we're robust to DBs later adding
+      # support for partial indexes.
+      def not_most_recent_value
+        return db_false if transition_class.columns_hash["most_recent"].null == false
+
+        nil
       end
     end
 

data/lib/statesman/config.rb

@@ -14,5 +14,31 @@ module Statesman
     def storage_adapter(adapter_class)
       @adapter_class = adapter_class
     end
+
+    def mysql_gaplock_protection?
+      return @mysql_gaplock_protection unless @mysql_gaplock_protection.nil?
+
+      # If our adapter class suggests we're using mysql, enable gaplock protection by
+      # default.
+      enable_mysql_gaplock_protection if mysql_adapter?(adapter_class)
+      @mysql_gaplock_protection
+    end
+
+    def enable_mysql_gaplock_protection
+      @mysql_gaplock_protection = true
+    end
+
+    private
+
+    def mysql_adapter?(adapter_class)
+      adapter_name = adapter_name(adapter_class)
+      return false unless adapter_name
+
+      adapter_name.start_with?("mysql")
+    end
+
+    def adapter_name(adapter_class)
+      adapter_class.respond_to?(:adapter_name) && adapter_class&.adapter_name
+    end
   end
 end

data/lib/statesman/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Statesman
-  VERSION = "7.1.0"
+  VERSION = "7.2.0"
 end

data/spec/statesman/adapters/active_record_queries_spec.rb

@@ -20,7 +20,9 @@ describe Statesman::Adapters::ActiveRecordQueries, active_record: true do
     prepare_other_model_table
     prepare_other_transitions_table
 
-    Statesman.configure { storage_adapter(Statesman::Adapters::ActiveRecord) }
+    Statesman.configure do
+      storage_adapter(Statesman::Adapters::ActiveRecord)
+    end
   end
 
   after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }

data/spec/statesman/adapters/active_record_spec.rb

@@ -9,9 +9,19 @@ describe Statesman::Adapters::ActiveRecord, active_record: true do
   before do
     prepare_model_table
     prepare_transitions_table
+
+    MyActiveRecordModelTransition.serialize(:metadata, JSON)
+
+    Statesman.configure do
+      # Rubocop requires described_class to be used, but this block
+      # is instance_eval'd and described_class won't be defined
+      # rubocop:disable RSpec/DescribedClass
+      storage_adapter(Statesman::Adapters::ActiveRecord)
+      # rubocop:enable RSpec/DescribedClass
+    end
   end
 
-  before { MyActiveRecordModelTransition.serialize(:metadata, JSON) }
+  after { Statesman.configure { storage_adapter(Statesman::Adapters::Memory) } }
 
   let(:observer) { double(Statesman::Machine, execute: nil) }
   let(:model) { MyActiveRecordModel.create(current_state: :pending) }

data/statesman.gemspec

@@ -25,7 +25,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 2.1.4"
   spec.add_development_dependency "gc_ruboconfig", "~> 2.3.9"
   spec.add_development_dependency "mysql2", ">= 0.4", "< 0.6"
-  spec.add_development_dependency "pg", "~> 0.18"
+  spec.add_development_dependency "pg", ">= 0.18", "<= 1.3"
   spec.add_development_dependency "pry"
   spec.add_development_dependency "rails", ">= 5.2"
   spec.add_development_dependency "rake", "~> 13.0.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: statesman
 version: !ruby/object:Gem::Version
-  version: 7.1.0
+  version: 7.2.0
 platform: ruby
 authors:
 - GoCardless
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-10 00:00:00.000000000 Z
+date: 2020-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ammeter
@@ -76,16 +76,22 @@ dependencies:
   name: pg
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.18'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0.18'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '1.3'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -292,7 +298,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.2
+rubygems_version: 3.1.1
 signing_key: 
 specification_version: 4
 summary: A statesman-like state machine library