fibered_mysql2 0.1.0.pre.3 → 0.1.0.pre.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 767c4a6d73b876ca435d3221bdcaa298046560cd3aa1e8b946a65790c654bf1e
-  data.tar.gz: aa0b3d54109e0e006832d7fa2fc02b99bf6b018fea394104d0ab9f1cc455d6b5
+  metadata.gz: 52a7c1f9db37bca0d6b9861985ad594863e1cde7847952dc83a2ed94bed72d2e
+  data.tar.gz: 1ac220f2391d1b7c74df9985ddfaca59855570ee01e36f8351841f8651306a98
 SHA512:
-  metadata.gz: b8fdbb7e5fa9b592e5a17c58b42878470e8d3d25589612229bdc078c628cc6c9240c9b9626faaa72e4e9092a38414cbae5c77a616aa2fc4cae3f4eecc834fbc3
-  data.tar.gz: c150c9d2af4a45350f67e518fb0efb279e91b2b2fe5a28479f4e344abf7587e51ae09e77423ea78602b2fee5e2a3c1bc1d971af4f4b4b4a12c3ea6777724ed54
+  metadata.gz: 4df2ada93ac02bf3b34b6a223c83c26690a620a88eec6c38ffc4f1a1c8a052867fc126b4f745ad3e1aa9278e86a7808c08dc7b493dbd99cb93812895b1901584
+  data.tar.gz: 78fafb964db2b16da1604032ea1421b2761f81ef60c52851be4df30f96e78a9f688b9a656fec1d4a0ad4b1564aca20f57bb9722a69aba64be4891835d11cfd6e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fibered_mysql2 (0.1.0.pre.3)
+    fibered_mysql2 (0.1.0.pre.4)
       em-synchrony (~> 1.0)
       rails (>= 4.2, < 7)
 

data/lib/fibered_mysql2.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
-require "fibered_mysql2/version"
+require 'fibered_mysql2/version'
+require_relative '../lib/active_record/connection_adapters/fibered_mysql2_adapter'
+require 'fibered_mysql2/fibered_database_connection_pool'
+require 'fibered_mysql2/fibered_mutex_with_waiter_priority'
+require 'fibered_mysql2/fibered_mysql2_connection_factory'
 
 module FiberedMysql2
   class Error < StandardError; end

data/lib/fibered_mysql2/fibered_database_connection_pool.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+# This class behaves the same as ActiveRecord's ConnectionPool, but synchronizes with fibers rather than threads.
+
+# Note - trace statements have been commented out.  This is useful trace but we do not want it on by default.
+#        When we have configurable logging we can put this back and have it off by default.
+
+require 'em-synchrony'
+require 'em-synchrony/thread'
+require 'fibered_mysql2/fibered_mutex_with_waiter_priority'
+
+EventMachine::Synchrony::Thread::Mutex.prepend(FiberedMysql2::FiberedMutexWithWaiterPriority)
+
+module FiberedMysql2
+  class FiberedConditionVariable < MonitorMixin::ConditionVariable
+    def initialize(monitor)
+      @monitor = monitor
+      @cond = EM::Synchrony::Thread::ConditionVariable.new
+    end
+  end
+
+  # From Ruby's MonitorMixin, with all occurrences of Thread changed to Fiber
+  module FiberedMonitorMixin
+    def self.extend_object(obj)
+      super
+      obj.__send__(:mon_initialize)
+    end
+
+    #
+    # Attempts to enter exclusive section.  Returns +false+ if lock fails.
+    #
+    def mon_try_enter
+      if @mon_owner != Fiber.current
+        @mon_mutex.try_lock or return false
+        @mon_owner = Fiber.current
+        @mon_count = 0
+      end
+      @mon_count += 1
+      true
+    end
+
+    #
+    # Enters exclusive section.
+    #
+    def mon_enter
+      if @mon_owner != Fiber.current
+        @mon_mutex.lock
+        @mon_owner = Fiber.current
+        @mon_count = 0
+      end
+      @mon_count += 1
+    end
+
+    #
+    # Leaves exclusive section.
+    #
+    def mon_exit
+      mon_check_owner
+      @mon_count -= 1
+      if @mon_count == 0
+        @mon_owner = nil
+        @mon_mutex.unlock
+      end
+    end
+
+    #
+    # Enters exclusive section and executes the block.  Leaves the exclusive
+    # section automatically when the block exits.  See example under
+    # +MonitorMixin+.
+    #
+    def mon_synchronize
+      mon_enter
+      begin
+        yield
+      ensure
+        begin
+          mon_exit
+        rescue => ex
+          ActiveRecord::Base.logger.error("Exception occurred while executing mon_exit: #{ex}")
+        end
+      end
+    end
+    alias synchronize mon_synchronize
+
+    #
+    # Creates a new FiberedConditionVariable associated with the
+    # receiver.
+    #
+    def new_cond
+      FiberedConditionVariable.new(self)
+    end
+
+    private
+
+    # Initializes the FiberedMonitorMixin after being included in a class
+    def mon_initialize
+      @mon_owner = nil
+      @mon_count = 0
+      @mon_mutex = EM::Synchrony::Thread::Mutex.new
+    end
+
+    def mon_check_owner
+      @mon_owner == Fiber.current or raise FiberError, "current fiber not owner"
+    end
+
+    def mon_enter_for_cond(count)
+      @mon_owner = Fiber.current
+      @mon_count = count
+    end
+
+    # returns the old mon_count
+    def mon_exit_for_cond
+      count = @mon_count
+      @mon_owner = nil
+      @mon_count = 0
+      count
+    end
+  end
+
+  module FiberedDatabaseConnectionPool
+    include FiberedMonitorMixin
+
+    module Adapter_4_2
+      def cached_connections
+        @reserved_connections
+      end
+    end
+
+    module Adapter_5_2
+      def cached_connections
+        @thread_cached_conns
+      end
+    end
+
+    case Rails::VERSION::MAJOR
+    when 4
+      include Adapter_4_2
+    when 5, 6
+      include Adapter_5_2
+    end
+
+    def initialize(connection_spec)
+      connection_spec.config[:reaping_frequency] and raise "reaping_frequency is not supported (the ActiveRecord Reaper is thread-based)"
+
+      super(connection_spec)
+
+      @reaper = nil # no need to keep a reference to this since it does nothing in this sub-class
+
+      # note that @reserved_connections is a ThreadSafe::Cache which is overkill in a fibered world, but harmless
+    end
+
+    def connection
+      # this is correctly done double-checked locking
+      # (ThreadSafe::Cache's lookups have volatile semantics)
+      if (result = cached_connections[current_connection_id])
+        result
+      else
+        synchronize do
+          if (result = cached_connections[current_connection_id])
+            result
+          else
+            cached_connections[current_connection_id] = checkout
+          end
+        end
+      end
+    end
+
+    if Rails::VERSION::MAJOR > 4
+      def release_connection(owner_thread = Fiber.current)
+        if (conn = @thread_cached_conns.delete(connection_cache_key(owner_thread)))
+          checkin(conn)
+        end
+      end
+    end
+
+    def current_connection_id
+      case Rails::VERSION::MAJOR
+      when 4
+        ActiveRecord::Base.connection_id ||= Fiber.current.object_id
+      else
+        connection_cache_key(current_thread)
+      end
+    end
+
+    def checkout(checkout_timeout = @checkout_timeout)
+      begin
+        reap_connections
+      rescue => ex
+        ActiveRecord::Base.logger.error("Exception occurred while executing reap_connections: #{ex}")
+      end
+      if Rails::VERSION::MAJOR > 4
+        super
+      else
+        super()
+      end
+    end
+
+    def reap_connections
+      cached_connections.values.each do |connection|
+        unless connection.owner.alive?
+          checkin(connection)
+        end
+      end
+    end
+
+    private
+
+    #--
+    # This hook-in method allows for easier monkey-patching fixes needed by
+    # JRuby users that use Fibers.
+    def connection_cache_key(fiber)
+      fiber
+    end
+
+    def current_thread
+      Fiber.current
+    end
+  end
+end
+
+ActiveRecord::ConnectionAdapters::ConnectionPool.prepend(FiberedMysql2::FiberedDatabaseConnectionPool)

data/lib/fibered_mysql2/fibered_mutex_with_waiter_priority.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module FiberedMysql2
+  module FiberedMutexWithWaiterPriority
+    # Note: @waiters is a bit confusing because the first waiter is actually the current fiber that has it locked;
+    # the _rest_ of @waiters are the actual waiters
+    def sleep(timeout = nil)
+      unlock
+      beg = Time.now
+      current = Fiber.current
+      @slept[current] = true
+      if timeout
+        timer = EM.add_timer(timeout) do
+          _wakeup(current)
+        end
+        Fiber.yield
+        EM.cancel_timer(timer) # if we resumed not via timer
+      else
+        Fiber.yield
+      end
+      @slept.delete(current)
+      yield if block_given?
+
+      # Invoca patch: inline lock that puts us at the front of the mutex @waiters queue instead of the back
+      # ==========================
+      @waiters.unshift(current)
+      Fiber.yield if @waiters.size > 1
+      # ==========================
+
+      Time.now - beg
+    end
+  end
+end

data/lib/fibered_mysql2/fibered_mysql2_connection_factory.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require_relative '../active_record/connection_adapters/fibered_mysql2_adapter'
+
+module EM::Synchrony
+  module ActiveRecord
+    _ = Adapter_4_2
+    module Adapter_4_2
+      def configure_connection
+        super                   # undo EM::Synchrony's override here
+      end
+
+      def transaction(*args)
+        super                   # and here
+      end
+
+      _ = TransactionManager
+      class TransactionManager < _
+        if Rails::VERSION::MAJOR > 5
+          # Overriding the em-synchrony override to bring it up to rails 6 requirements.
+          # Changes from the original Rails 6 source are:
+          #   1. the usage of _current_stack created by em-synchrony instead of the Rails provided @stack instance variable
+          #   2. the usage of Fiber.current.object_id as a part of the savepoint transaction name
+          #
+          # Original EM Synchrony Source:
+          # https://github.com/igrigorik/em-synchrony/blob/master/lib/em-synchrony/activerecord_4_2.rb#L35-L44
+          #
+          # Original Rails Source:
+          # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/connection_adapters/abstract/transaction.rb#L205-L224
+          def begin_transaction(options = {})
+            @connection.lock.synchronize do
+              run_commit_callbacks = !current_transaction.joinable?
+              transaction =
+                  if _current_stack.empty?
+                    ::ActiveRecord::ConnectionAdapters::RealTransaction.new(@connection, options, run_commit_callbacks: run_commit_callbacks)
+                  else
+                    ::ActiveRecord::ConnectionAdapters::SavepointTransaction.new(@connection, "active_record_#{Fiber.current.object_id}_#{open_transactions}", _current_stack.last, options,
+                                                                                 run_commit_callbacks: run_commit_callbacks)
+                  end
+
+              if @connection.supports_lazy_transactions? && lazy_transactions_enabled? && options[:_lazy] != false
+                @has_unmaterialized_transactions = true
+              else
+                transaction.materialize!
+              end
+              _current_stack.push(transaction)
+              transaction
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module FiberedMysql2
+  module FiberedMysql2ConnectionFactory
+    def fibered_mysql2_connection(raw_config)
+      config = raw_config.symbolize_keys
+
+      config[:username] = 'root' if config[:username].nil?
+      config[:flags]    = Mysql2::Client::FOUND_ROWS if Mysql2::Client.const_defined?(:FOUND_ROWS)
+
+      client =
+          begin
+            Mysql2::EM::Client.new(config)
+          rescue Mysql2::Error => error
+            if error.message.include?("Unknown database")
+              raise ActiveRecord::NoDatabaseError.new(error.message, error)
+            else
+              raise
+            end
+          end
+
+      options = [config[:host], config[:username], config[:password], config[:database], config[:port], config[:socket], 0]
+      FiberedMysql2Adapter.new(client, logger, options, config)
+    end
+  end
+end
+
+ActiveRecord::Base.class.prepend(FiberedMysql2::FiberedMysql2ConnectionFactory)

data/lib/fibered_mysql2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FiberedMysql2
-  VERSION = "0.1.0.pre.3"
+  VERSION = "0.1.0.pre.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fibered_mysql2
 version: !ruby/object:Gem::Version
-  version: 0.1.0.pre.3
+  version: 0.1.0.pre.4
 platform: ruby
 authors:
 - Octothorp
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-10-07 00:00:00.000000000 Z
+date: 2020-10-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: em-synchrony
@@ -68,6 +68,9 @@ files:
 - gemfiles/rails_6.gemfile
 - lib/active_record/connection_adapters/fibered_mysql2_adapter.rb
 - lib/fibered_mysql2.rb
+- lib/fibered_mysql2/fibered_database_connection_pool.rb
+- lib/fibered_mysql2/fibered_mutex_with_waiter_priority.rb
+- lib/fibered_mysql2/fibered_mysql2_connection_factory.rb
 - lib/fibered_mysql2/version.rb
 homepage: https://github.com/Invoca/fibered_mysql2
 licenses: []