transaction_isolation_continued 1.0.5

data/lib/transaction_isolation/active_record/connection_adapters/postgresql_adapter.rb

@@ -0,0 +1,81 @@
+if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+
+  module TransactionIsolation
+    module ActiveRecord
+      module ConnectionAdapters # :nodoc:
+        module PostgreSQLAdapter
+
+          def self.included( base )
+            base.class_eval do
+              alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
+              alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
+            end
+          end
+
+          def supports_isolation_levels?
+            true
+          end
+
+          VENDOR_ISOLATION_LEVEL = {
+              :read_uncommitted => 'READ UNCOMMITTED',
+              :read_committed => 'READ COMMITTED',
+              :repeatable_read => 'REPEATABLE READ',
+              :serializable => 'SERIALIZABLE'
+          }
+
+          ANSI_ISOLATION_LEVEL = {
+              'READ UNCOMMITTED' => :read_uncommitted,
+              'READ COMMITTED' => :read_committed,
+              'REPEATABLE READ' => :repeatable_read,
+              'SERIALIZABLE' => :serializable
+          }
+
+          def current_isolation_level
+            ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
+          end
+
+          def current_vendor_isolation_level
+            select_value( "SHOW TRANSACTION ISOLATION LEVEL" ).upcase
+          end
+
+          def isolation_level( level )
+            validate_isolation_level( level )
+
+            original_vendor_isolation_level = current_vendor_isolation_level if block_given?
+
+            execute "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL #{VENDOR_ISOLATION_LEVEL[level]}"
+
+            begin
+              yield
+            ensure
+              execute "SET SESSION CHARACTERISTICS AS TRANSACTION ISOLATION LEVEL #{original_vendor_isolation_level}"
+            end if block_given?
+          end
+
+          def translate_exception_with_transaction_isolation_conflict(*args)
+            exception = args.first
+
+            if isolation_conflict?(exception)
+              ::ActiveRecord::TransactionIsolationConflict.new("Transaction isolation conflict detected: #{exception.message}")
+            else
+              translate_exception_without_transaction_isolation_conflict(*args)
+            end
+          end
+
+          ruby2_keywords :translate_exception_with_transaction_isolation_conflict if respond_to?(:ruby2_keywords, true)
+
+          def isolation_conflict?( exception )
+            [ "deadlock detected",
+              "could not serialize access" ].any? do |error_message|
+              exception.message =~ /#{Regexp.escape( error_message )}/i
+            end
+          end
+
+        end
+      end
+    end
+  end
+
+  ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+
+end

data/lib/transaction_isolation/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,80 @@
+if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+
+  module TransactionIsolation
+    module ActiveRecord
+      module ConnectionAdapters # :nodoc:
+        module SQLite3Adapter
+
+          def self.included( base )
+            base.class_eval do
+              alias_method :translate_exception_without_transaction_isolation_conflict, :translate_exception
+              alias_method :translate_exception, :translate_exception_with_transaction_isolation_conflict
+            end
+          end
+
+          def supports_isolation_levels?
+            true
+          end
+
+          VENDOR_ISOLATION_LEVEL = {
+              :read_uncommitted => 'read_uncommitted = 1',
+              :read_committed => 'read_uncommitted = 0',
+              :repeatable_read => 'read_uncommitted = 0',
+              :serializable => 'read_uncommitted = 0'
+          }
+
+          ANSI_ISOLATION_LEVEL = {
+              'read_uncommitted = 1' => :read_uncommitted,
+              'read_uncommitted = 0' => :serializable
+          }
+
+          def current_isolation_level
+            ANSI_ISOLATION_LEVEL[current_vendor_isolation_level]
+          end
+
+          def current_vendor_isolation_level
+            "read_uncommitted = #{select_value( "PRAGMA read_uncommitted" )}"
+          end
+
+          def isolation_level( level )
+            validate_isolation_level( level )
+
+            original_vendor_isolation_level = current_vendor_isolation_level if block_given?
+
+            execute "PRAGMA #{VENDOR_ISOLATION_LEVEL[level]}"
+
+            begin
+              yield
+            ensure
+              execute "PRAGMA #{original_vendor_isolation_level}"
+            end if block_given?
+          end
+
+          def translate_exception_with_transaction_isolation_conflict(*args)
+            exception = args.first
+
+            if isolation_conflict?(exception)
+              ::ActiveRecord::TransactionIsolationConflict.new("Transaction isolation conflict detected: #{exception.message}")
+            else
+              translate_exception_without_transaction_isolation_conflict(*args)
+            end
+          end
+
+          ruby2_keywords :translate_exception_with_transaction_isolation_conflict if respond_to?(:ruby2_keywords, true)
+
+          # http://www.sqlite.org/c3ref/c_abort.html
+          def isolation_conflict?( exception )
+            [ "The database file is locked",
+              "A table in the database is locked",
+              "Database lock protocol error"].any? do |error_message|
+              exception.message =~ /#{Regexp.escape( error_message )}/i
+            end
+          end
+        end
+      end
+    end
+  end
+
+  ActiveRecord::ConnectionAdapters::SQLite3Adapter.send( :include, TransactionIsolation::ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+
+end

data/lib/transaction_isolation/active_record/errors.rb

@@ -0,0 +1,10 @@
+require 'active_record/errors'
+
+module ActiveRecord
+  # This exception represents both deadlocks and serialization conflicts.
+  # Deadlocks happen when db engine is using lock-based concurrency control.
+  # Serialization conflicts happen when db engine is using multi-version concurrency control.
+  # Often db engines combine both approaches and thus generate both types of errors.
+
+  class TransactionIsolationConflict < ::ActiveRecord::WrappedDatabaseException; end
+end

data/lib/transaction_isolation/configuration.rb

@@ -0,0 +1,19 @@
+module TransactionIsolation
+  class Configuration
+    attr_accessor :mysql_isolation_variable
+    attr_accessor :detect_mysql_isolation_variable
+
+    def initialize
+      @mysql_isolation_variable = 'tx_isolation'
+      @detect_mysql_isolation_variable = true
+    end
+
+    def mysql_isolation_variable=( value )
+      unless value.in? %w[transaction_isolation tx_isolation]
+        raise ArgumentError, "Invalid MySQL isolation variable '#{value}'. Supported variables include 'transaction_isolation' and 'tx_isolation'."
+      end
+
+      @mysql_isolation_variable = value
+    end
+  end
+end

data/lib/transaction_isolation/version.rb

@@ -0,0 +1,3 @@
+module TransactionIsolation
+  VERSION = "1.0.5"
+end

data/lib/transaction_isolation.rb

@@ -0,0 +1,51 @@
+require "active_record"
+require_relative 'transaction_isolation/version'
+require_relative 'transaction_isolation/configuration'
+
+module TransactionIsolation
+
+  # Must be called after ActiveRecord established a connection.
+  # Only then we know which connection adapter is actually loaded and can be enhanced.
+  # Please note ActiveRecord does not load unused adapters.
+  def self.apply_activerecord_patch
+    require_relative 'transaction_isolation/active_record/errors'
+    require_relative 'transaction_isolation/active_record/base'
+    require_relative 'transaction_isolation/active_record/connection_adapters/abstract_adapter'
+    require_relative 'transaction_isolation/active_record/connection_adapters/mysql2_adapter'
+    require_relative 'transaction_isolation/active_record/connection_adapters/postgresql_adapter'
+    require_relative 'transaction_isolation/active_record/connection_adapters/sqlite3_adapter'
+  end
+
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    config = configuration
+    yield(config)
+  end
+
+  def self.config
+    config = configuration
+    yield(config) if block_given?
+    config
+  end
+
+  if defined?( ::Rails )
+    # Setup applying the patch after Rails is initialized.
+    class Railtie < ::Rails::Railtie
+      config.after_initialize do
+        if ActiveRecord::Base.connection.adapter_name == 'Mysql2' && TransactionIsolation.config.detect_mysql_isolation_variable
+          mysql_version = ActiveRecord::Base.connection.select_value('SELECT version()')
+          if mysql_version >= '8'
+            TransactionIsolation.config.mysql_isolation_variable = 'transaction_isolation'
+          else
+            TransactionIsolation.config.mysql_isolation_variable = 'tx_isolation'
+          end
+        end
+        TransactionIsolation.apply_activerecord_patch
+      end
+    end
+  end
+
+end

data/test/db/all.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require_relative 'db'
+require_relative 'migrations'
+require_relative 'queued_job'

data/test/db/db.rb

@@ -0,0 +1,37 @@
+require 'fileutils'
+
+module TransactionIsolation
+  module Test
+    module Db
+
+      def self.connect_to_mysql2
+        ::ActiveRecord::Base.establish_connection(
+          :adapter => "mysql2",
+          :database => ENV['MYSQL_DB_NAME'],
+          :host => ENV['MYSQL_DB_HOST'],
+          :user => 'root',
+          :password => ENV['MYSQL_DB_PASS']
+        )
+      end
+
+      def self.connect_to_postgresql
+        ::ActiveRecord::Base.establish_connection(
+          :adapter => "postgresql",
+          :database => ENV['POSTGRESQL_DB_NAME'],
+          :host => ENV['POSTGRESQL_DB_HOST'],
+          :user => ENV['POSTGRESQL_DB_USER'],
+          :password => ENV['POSTGRESQL_DB_PASS']
+        )
+      end
+
+      def self.connect_to_sqlite3
+        ActiveRecord::Base.establish_connection(
+          :adapter => "sqlite3",
+          :database => ":memory:",
+          :verbosity => "silent"
+        )
+      end
+
+    end
+  end
+end

data/test/db/migrations.rb

@@ -0,0 +1,20 @@
+module TransactionIsolation
+  module Test
+    module Migrations
+
+      def self.run!
+        c = ::ActiveRecord::Base.connection
+
+        # Queued Jobs
+        
+        c.create_table "queued_jobs", :force => true do |t|
+          t.text     "job",                               :null => false
+          t.integer  "status",     :default => 0,         :null => false
+          t.timestamps
+        end
+
+      end
+
+    end
+  end
+end

data/test/db/queued_job.rb

@@ -0,0 +1,2 @@
+class QueuedJob < ActiveRecord::Base
+end

data/test/integration/active_record/base/isolation_level_test.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < Minitest::Test
+
+  class BaseTest < Minitest::Test
+
+    class IsolationLevelTest < Minitest::Test
+
+      def test_wraps_connection_isolation_level
+        ActiveRecord::Base.isolation_level( :serializable ) do
+          ActiveRecord::Base.transaction do
+            assert_equal( :serializable, ActiveRecord::Base.connection.current_isolation_level )
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/current_isolation_level_test.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < Minitest::Test
+
+  class ConnectionAdaptersTest < Minitest::Test
+
+    class AnyAdapterTest < Minitest::Test
+
+      class CurrentIsolationLevelTest < Minitest::Test
+
+        def test_returns_correct_default_isolation_level
+          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+            assert_equal( :repeatable_read, ActiveRecord::Base.connection.current_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+            assert_equal( :read_committed, ActiveRecord::Base.connection.current_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+            assert_equal( :serializable, ActiveRecord::Base.connection.current_isolation_level )
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/current_vendor_isolation_level_test.rb

@@ -0,0 +1,33 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < Minitest::Test
+
+  class ConnectionAdaptersTest < Minitest::Test
+
+    class AnyAdapterTest < Minitest::Test
+
+      class CurrentVendorIsolationLevelTest < Minitest::Test
+
+        def test_returns_correct_default_vendor_isolation_level
+          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+            assert_equal( 'REPEATABLE READ', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+            assert_equal( 'READ COMMITTED', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          end
+
+          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+            assert_equal( 'read_uncommitted = 0', ActiveRecord::Base.connection.current_vendor_isolation_level )
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/isolation_level_test.rb

@@ -0,0 +1,69 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < Minitest::Test
+
+  class ConnectionAdaptersTest < Minitest::Test
+
+    class AnyAdapterTest < Minitest::Test
+
+      class IsolationLevelTest < Minitest::Test
+
+        def test_without_a_block
+          original_isolation_level = ActiveRecord::Base.connection.current_isolation_level
+
+          ActiveRecord::Base.connection.isolation_level( :read_uncommitted )
+          assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+
+          ActiveRecord::Base.connection.isolation_level( original_isolation_level )
+          assert_equal( original_isolation_level, ActiveRecord::Base.connection.current_isolation_level )
+        end
+
+        def test_with_a_block
+          original_isolation_level = ActiveRecord::Base.connection.current_isolation_level
+          refute_equal( :read_uncommitted, original_isolation_level )
+
+          ActiveRecord::Base.connection.isolation_level( :read_uncommitted ) do
+            assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+            ActiveRecord::Base.transaction do
+              assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+              QueuedJob.count
+              QueuedJob.first
+              assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+            end
+            assert_equal( :read_uncommitted, ActiveRecord::Base.connection.current_isolation_level )
+          end
+
+          assert_equal( original_isolation_level, ActiveRecord::Base.connection.current_isolation_level )
+        end
+
+        def test_with_all_possible_ansi_levels
+          [:read_uncommitted, :read_committed, :repeatable_read, :serializable].each do |ansi_level|
+
+            QueuedJob.isolation_level( ansi_level ) do
+
+              # Some typical usage
+              QueuedJob.transaction do
+                QueuedJob.create!( :job => 'is fun' )
+                assert_equal( 1, QueuedJob.count )
+                raise ActiveRecord::Rollback
+              end
+
+            end
+          end
+        end
+
+        def test_with_invalid_isolation_level
+          assert_raises( ArgumentError ) do
+            QueuedJob.isolation_level( :dupa )
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/supports_isolation_levels_test.rb

@@ -0,0 +1,23 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < Minitest::Test
+
+  class ConnectionAdaptersTest < Minitest::Test
+
+    class AnyAdapterTest < Minitest::Test
+
+      class SupportsIsolationLevelsTest < Minitest::Test
+
+        def test_returns_true
+          assert( ActiveRecord::Base.connection.supports_isolation_levels? )
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/integration/active_record/connection_adapters/any_adapter/translate_exception_test.rb

@@ -0,0 +1,46 @@
+# -*- encoding : utf-8 -*-
+
+require 'test_helper'
+
+class ActiveRecordTest < Minitest::Test
+
+  class ConnectionAdaptersTest < Minitest::Test
+
+    class AnyAdapterTest < Minitest::Test
+
+      class TranslateExceptionTest < Minitest::Test
+
+        def test_does_not_break_existing_translation
+          assert_raises( ActiveRecord::StatementInvalid ) do
+            ActiveRecord::Base.connection.execute( "WE LIVE IN THE MOST EXCITING TIMES EVER" )
+          end
+        end
+
+        def test_translates_low_level_exceptions_to_transaction_isolation_level
+          if defined?( ActiveRecord::ConnectionAdapters::Mysql2Adapter )
+            message = "Deadlock found when trying to get lock"
+            translated_exception = ActiveRecord::Base.connection.send( :translate_exception, Mysql2::Error.new( message ), message: message, sql: nil, binds: nil )
+            assert_equal( ActiveRecord::TransactionIsolationConflict, translated_exception.class )
+          end
+          
+          if defined?( ActiveRecord::ConnectionAdapters::PostgreSQLAdapter )
+            message = "deadlock detected"
+            translated_exception = ActiveRecord::Base.connection.send( :translate_exception, PG::Error.new( message ), message: message, sql: nil, binds: nil )
+            assert_equal( ActiveRecord::TransactionIsolationConflict, translated_exception.class )
+          end
+          
+          if defined?( ActiveRecord::ConnectionAdapters::SQLite3Adapter )
+            message = "The database file is locked"
+            translated_exception = ActiveRecord::Base.connection.send( :translate_exception, StandardError.new( message ), message: message, sql: nil, binds: nil )
+            assert_equal( ActiveRecord::TransactionIsolationConflict, translated_exception.class )
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/test/library_setup.rb

@@ -0,0 +1,25 @@
+# Prepares application to be tested (requires files, connects to db, resets schema and data, applies patches, etc.)
+
+# Initialize database
+require 'db/all'
+
+case ENV['db']
+  when 'mysql2'
+    TransactionIsolation::Test::Db.connect_to_mysql2
+  when 'postgresql'
+    TransactionIsolation::Test::Db.connect_to_postgresql
+  when 'sqlite3'
+    TransactionIsolation::Test::Db.connect_to_sqlite3
+  else
+    TransactionIsolation::Test::Db.connect_to_sqlite3
+end
+
+TransactionIsolation::Test::Migrations.run!
+
+# Load the code that will be tested
+require 'transaction_isolation'
+
+require 'logger'
+ActiveRecord::Base.logger = Logger.new( File.expand_path( "#{File.dirname( __FILE__ )}/log/test.log" ) )
+
+TransactionIsolation.apply_activerecord_patch

data/test/test_console.rb

@@ -0,0 +1,11 @@
+# Ensure that LOAD_PATH is the same as when running "rake test"; normally rake takes care of that
+$LOAD_PATH << File.expand_path( ".", File.dirname( __FILE__ ) )
+$LOAD_PATH << File.expand_path( "./lib", File.dirname( __FILE__ ) )
+$LOAD_PATH << File.expand_path( "./test", File.dirname( __FILE__ ) )
+
+# Boot the app
+require_relative 'library_setup'
+
+# Fire the console
+require 'pry'
+binding.pry

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+# Load test coverage tool (must be loaded before any code)
+#require 'simplecov'
+#SimpleCov.start do
+#  add_filter '/test/'
+#  add_filter '/config/'
+#end
+
+# Load and initialize the application to be tested
+require 'library_setup'
+
+# Load test frameworks
+require 'minitest/autorun'

data/test/test_runner.rb

@@ -0,0 +1,4 @@
+require 'test_helper'
+
+# Load all tests
+Dir.glob( "./**/*_test.rb" ).each { |test_file| require test_file }

data/tests

@@ -0,0 +1,6 @@
+
+db=mysql2 bundle exec rake
+
+db=postgresql bundle exec rake
+
+db=sqlite3 bundle exec rake

data/transaction_isolation_continued.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "transaction_isolation/version"
+
+Gem::Specification.new do |s|
+  s.name        = "transaction_isolation_continued"
+  s.version     = TransactionIsolation::VERSION
+  s.authors     = ["Piotr 'Qertoip' Włodarek"]
+  s.email       = ["qertoip@gmail.com"]
+  s.homepage    = "https://github.com/qertoip/transaction_isolation"
+  s.summary     = %q{Set transaction isolation level in the ActiveRecord in a database agnostic way.}
+  s.description = %q{Set transaction isolation level in the ActiveRecord in a database agnostic way.
+Works with MySQL, PostgreSQL and SQLite as long as you are using new adapters mysql2, pg or sqlite3.
+Supports all ANSI SQL isolation levels: :serializable, :repeatable_read, :read_committed, :read_uncommitted.}
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake', '~> 13.0'
+  s.add_development_dependency 'minitest', '5.3.4'
+  s.add_runtime_dependency "activerecord", ">= 5.2"
+end