fibered_mysql2 0.4.0.pre.tstarck.3 → 1.0.0.colin.1

data/lib/active_record/connection_adapters/fibered_mysql2_adapter.rb

@@ -1,176 +1,76 @@
 # frozen_string_literal: true
 
-require 'em-synchrony'
 require 'active_model'
 require 'active_record/errors'
-
 require 'active_record/connection_adapters/mysql2_adapter'
-require 'em-synchrony/mysql2'
+require_relative '../../fibered_mysql2/async_task'
 
 module FiberedMysql2
-  module FiberedMysql2Adapter_7_0
+  module FiberedMysql2Adapter_6
     def lease
-      if in_use?
-        msg = "Cannot lease connection, ".dup
-        if owner_fiber == Fiber.current
-          msg << "it is already leased by the current fiber."
+      if (ot = owner_task)
+        msg = +"Cannot lease connection; "
+        if ot == (current_task = AsyncTask.current_or_none)
+          msg << "it is already leased by the current Async::Task."
         else
-          msg << "it is already in use by a different fiber: #{owner_fiber}. " \
-                  "Current fiber: #{Fiber.current}."
+          msg << "it is already in use by a different Async::Task: #{ot}. " \
+                  "Current Async::Task: #{current_task}."
         end
         raise ::ActiveRecord::ActiveRecordError, msg
       end
 
-      @owner = Fiber.current
+      @owner = AsyncTask.current_or_none
     end
 
     def expire
-      if in_use?
-        # Because we are actively releasing connections from dead fibers, we only want
-        # to enforce that we're expiring the current fibers connection, iff the owner
+      if (ot = owner_task)
+        # Because we are actively releasing connections from dead tasks, we only want
+        # to enforce that we're expiring the current task's connection, iff the owner
         # of the connection is still alive.
-        if owner_fiber.alive? && owner_fiber != Fiber.current
-          raise ::ActiveRecord::ActiveRecordError, "Cannot expire connection, " \
-            "it is owned by a different fiber: #{owner_fiber}. " \
-            "Current fiber: #{Fiber.current}."
+        if ot.alive? && ot != (current_task = AsyncTask.current_or_none)
+          raise ::ActiveRecord::ActiveRecordError, "Cannot expire connection; " \
+            "it is owned by a different Async::Task: #{ot}. " \
+            "Current Async::Task: #{current_task}."
         end
 
         @idle_since = ::Concurrent.monotonic_time
         @owner = nil
       else
-        raise ::ActiveRecord::ActiveRecordError, "Cannot expire connection, it is not currently leased."
+        raise ::ActiveRecord::ActiveRecordError, "Cannot expire connection; it is not currently leased."
       end
     end
 
     def steal!
-      if in_use?
-        if owner_fiber != Fiber.current
-          pool.send :remove_connection_from_thread_cache, self, owner_fiber
+      if (ot = owner_task)
+        if ot != (current_task = AsyncTask.current_or_none)
+          pool.send :remove_connection_from_thread_cache, self, ot
 
-          @owner = Fiber.current
+          @owner = current_task
         end
       else
-        raise ::ActiveRecord::ActiveRecordError, "Cannot steal connection, it is not currently leased."
-      end
-    end
-
-    def reset_transaction #:nodoc:
-      @transaction_manager = ::FiberedMysql2::FiberedMysql2Adapter_7_0::TransactionManager.new(self)
-    end
-
-    class TransactionManager < ::ActiveRecord::ConnectionAdapters::TransactionManager
-      def initialize(...)
-        super
-        @stack = Hash.new { |h, k| h[k] = [] }
-      end
-
-      def current_transaction #:nodoc:
-        _current_stack.last || ::ActiveRecord::ConnectionAdapters::TransactionManager::NULL_TRANSACTION
-      end
-
-      def open_transactions
-        _current_stack.size
-      end
-
-      def begin_transaction(isolation: nil, joinable: true, _lazy: true)
-        @connection.lock.synchronize do
-          run_commit_callbacks = !current_transaction.joinable?
-          transaction =
-            if _current_stack.empty?
-              ::ActiveRecord::ConnectionAdapters::RealTransaction.new(@connection, isolation:, joinable:, run_commit_callbacks: run_commit_callbacks)
-            else
-              ::ActiveRecord::ConnectionAdapters::SavepointTransaction.new(@connection, "active_record_#{Fiber.current.object_id}_#{open_transactions}", _current_stack.last, isolation:, joinable:, run_commit_callbacks: run_commit_callbacks)
-            end
-
-          if @connection.supports_lazy_transactions? && lazy_transactions_enabled? && _lazy
-            @has_unmaterialized_transactions = true
-          else
-            transaction.materialize!
-          end
-          _current_stack.push(transaction)
-          transaction
-        end
-      end
-
-      # Overriding the ActiveRecord::TransactionManager#materialize_transactions method to use
-      # fiber safe the _current_stack instead of the @stack instance variable. when marterializing
-      # transactions.
-      def materialize_transactions
-        return if @materializing_transactions
-        return unless @has_unmaterialized_transactions
-
-        @connection.lock.synchronize do
-          begin
-            @materializing_transactions = true
-            _current_stack.each { |t| t.materialize! unless t.materialized? }
-          ensure
-            @materializing_transactions = false
-          end
-          @has_unmaterialized_transactions = false
-        end
-      end
-
-      # Overriding the ActiveRecord::TransactionManager#commit_transaction method to use
-      # fiber safe the _current_stack instead of the @stack instance variable. when marterializing
-      # transactions.
-      def commit_transaction
-        @connection.lock.synchronize do
-          transaction = _current_stack.last
-
-          begin
-            transaction.before_commit_records
-          ensure
-            _current_stack.pop
-          end
-
-          transaction.commit
-          transaction.commit_records
-        end
-      end
-
-      # Overriding the ActiveRecord::TransactionManager#rollback_transaction method to use
-      # fiber safe the _current_stack instead of the @stack instance variable. when marterializing
-      # transactions.
-      def rollback_transaction(transaction = nil)
-        @connection.lock.synchronize do
-          transaction ||= _current_stack.pop
-          transaction.rollback
-          transaction.rollback_records
-        end
-      end
-
-      private
-
-      def _current_stack
-        @stack[Fiber.current.object_id]
+        raise ::ActiveRecord::ActiveRecordError, "Cannot steal connection; it is not currently leased."
       end
     end
 
     private
 
-    def owner_fiber
-      @owner.nil? || @owner.is_a?(Fiber) or
-        raise "@owner must be a Fiber! Found #{@owner.inspect}"
+    def owner_task
+      @owner.nil? || @owner == AsyncTask::NoTaskPlaceholder || @owner.is_a?(Async::Task) or
+        raise "@owner must be an Async::Task or FiberedMysql2::AsyncTask::NoTaskPlaceholder! Found #{@owner.inspect}"
       @owner
     end
   end
 
   class FiberedMysql2Adapter < ::ActiveRecord::ConnectionAdapters::Mysql2Adapter
-    if ::ActiveRecord.gem_version < "7.1"
-      include FiberedMysql2Adapter_7_0
+    case ::Rails::VERSION::MAJOR
+    when 6
+      include FiberedMysql2Adapter_6
+    else
+      raise ArgumentError, "unexpected Rails version #{Rails::VERSION::MAJOR}"
     end
 
-    class << self
-      # Copied from Mysql2Adapter, except with the EM Mysql2 client
-      def new_client(config)
-        Mysql2::EM::Client.new(config)
-      rescue Mysql2::Error => error
-        if error.error_number == 1049
-          raise ActiveRecord::NoDatabaseError.new, error.message
-        else
-          raise ActiveRecord::ConnectionNotEstablished, error.message
-        end
-      end
+    def initialize(*args)
+      super
     end
   end
 end

data/lib/fibered_mysql2/async_task.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module FiberedMysql2
+  module AsyncTask
+    class NoTaskPlaceholder
+      class << self
+        def alive? = true
+      end
+    end
+
+    class << self
+      # Adapted from https://github.com/socketry/async/blob/main/lib/async/task.rb#L236-L238
+      def current_or_none
+        Thread.current[:async_task] || NoTaskPlaceholder
+      end
+    end
+  end
+end

data/lib/fibered_mysql2/fibered_database_connection_pool.rb

@@ -1,246 +1,52 @@
 # frozen_string_literal: true
 
-# This class behaves the same as ActiveRecord's ConnectionPool, but synchronizes with fibers rather than threads.
+# This class behaves the same as ActiveRecord's ConnectionPool, but synchronizes with Async::Task 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
-    EXCEPTION_NEVER = {Exception => :never}.freeze
-    EXCEPTION_IMMEDIATE = {Exception => :immediate}.freeze
-
-    #
-    # FIXME: This isn't documented in Nutshell.
-    #
-    # Since MonitorMixin.new_cond returns a ConditionVariable, and the example
-    # above calls while_wait and signal, this class should be documented.
-    #
-    class Timeout < Exception; end
-
-    #
-    # Releases the lock held in the associated monitor and waits; reacquires the lock on wakeup.
-    #
-    # If +timeout+ is given, this method returns after +timeout+ seconds passed,
-    # even if no other thread doesn't signal.
-    #
-    def wait(timeout = nil)
-      Thread.handle_interrupt(EXCEPTION_NEVER) do
-        @monitor.__send__(:mon_check_owner)
-        count = @monitor.__send__(:mon_exit_for_cond)
-        begin
-          Thread.handle_interrupt(EXCEPTION_IMMEDIATE) do
-            @cond.wait(@monitor.instance_variable_get(:@mon_mutex), timeout)
-          end
-          return true
-        ensure
-          @monitor.__send__(:mon_enter_for_cond, count)
-        end
-      end
-    end
-
-    #
-    # Calls wait repeatedly while the given block yields a truthy value.
-    #
-    def wait_while
-      while yield
-        wait
-      end
-    end
-
-    #
-    # Calls wait repeatedly until the given block yields a truthy value.
-    #
-    def wait_until
-      until yield
-        wait
-      end
-    end
-
-    #
-    # Wakes up the first thread in line waiting for this lock.
-    #
-    def signal
-      @monitor.__send__(:mon_check_owner)
-      @cond.signal
-    end
-
-    #
-    # Wakes up all threads waiting for this lock.
-    #
-    def broadcast
-      @monitor.__send__(:mon_check_owner)
-      @cond.broadcast
-    end
-
-    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
+  module FiberedDatabaseConnectionPool
+    case ::Rails::VERSION::MAJOR
+    when 6
+    else
+      raise ArgumentError, "unexpected Rails version #{Rails::VERSION::MAJOR}"
     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
+    def cached_connections
+      @thread_cached_conns
     end
 
-    #
-    # Leaves exclusive section.
-    #
-    def mon_exit
-      mon_check_owner
-      @mon_count -= 1
-      if @mon_count == 0
-        @mon_owner = nil
-        @mon_mutex.unlock
-      end
+    def current_connection_id
+      connection_cache_key(current_thread)
     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
+    def checkout(checkout_timeout = @checkout_timeout)
       begin
-        yield
-      ensure
-        begin
-          mon_exit
-        rescue => ex
-          ActiveRecord::Base.logger.error("Exception occurred while executing mon_exit: #{ex}")
-        end
+        reap_connections
+      rescue => ex
+        ActiveRecord::Base.logger.error("Exception occurred while executing reap_connections: #{ex.class}: #{ex.message}")
       end
+      super
     end
-    alias synchronize mon_synchronize
-
-    #
-    # Creates a new FiberedConditionVariable associated with the
-    # receiver.
-    #
-    def new_cond
-      FiberedConditionVariable.new(self)
-    end
-
-    # 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
-
-    private
-
-    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
-    module Adapter_7_0
-      def release_connection(owner_thread = Fiber.current)
-        if (conn = @thread_cached_conns.delete(connection_cache_key(owner_thread)))
-          checkin(conn)
-        end
+    def release_connection(owner_task = AsyncTask.current_or_none)
+      if (conn = @thread_cached_conns.delete(connection_cache_key(owner_task)))
+        checkin(conn)
       end
-
-      def with_connection
-        unless (conn = cached_connections[current_connection_id]) # Invoca Patch to use Fiber
-          conn = connection
-          fresh_connection = true
-        end
-        yield conn
-      ensure
-        release_connection if fresh_connection
-      end
-
-      def current_thread
-        Fiber.current
-      end
-    end
-
-    if ::ActiveRecord.gem_version < "7.1"
-      include Adapter_7_0
     end
-    include FiberedMonitorMixin # This is switches the connection pool's mutex and condition variables to event machine / Fiber compatible ones.
 
-    def initialize(pool_config)
-      if pool_config.db_config.reaping_frequency
-        pool_config.db_config.reaping_frequency > 0 and raise "reaping_frequency is not supported (the ActiveRecord Reaper is thread-based)"
-      end
+    def initialize(connection_spec, *args, **keyword_args)
+      connection_spec.config[:reaping_frequency] and raise "reaping_frequency is not supported (the ActiveRecord Reaper is thread-based)"
+      connection_spec.config[:reaping_frequency] = nil # starting in Rails 5, this defaults to 60 if not explicitly set
 
-      super(pool_config)
+      super(connection_spec, *args, **keyword_args)
 
       @reaper = nil # no need to keep a reference to this since it does nothing in this sub-class
-    end
-
-    def current_connection_id
-      connection_cache_key(current_thread)
-    end
-
-    def cached_connections
-      @thread_cached_conns
-    end
 
-    # Invoca patch that reaps orphaned connections on checkout. This lets us immediately use a connection left open by dead fibers
-    # instead of waiting for all connections to be used in the pool before they are reaped.
-    def checkout(checkout_timeout = @checkout_timeout)
-      begin
-        reap
-      rescue => ex
-        ActiveRecord::Base.logger.error("Exception occurred while executing reap_connections: #{ex}")
-      end
-      super
+      # note that @reserved_connections is a ThreadSafe::Cache which is overkill in a fibered world, but harmless
     end
 
-    # Invoca patch to ensure that we are using the current fiber's connection.
     def connection
       # this is correctly done double-checked locking
       # (ThreadSafe::Cache's lookups have volatile semantics)
@@ -256,6 +62,27 @@ module FiberedMysql2
         end
       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
+      AsyncTask.current_or_none
+    end
   end
 end
 

data/lib/fibered_mysql2/fibered_mysql2_connection_factory.rb

@@ -6,17 +6,23 @@ module FiberedMysql2
   module FiberedMysql2ConnectionFactory
     def fibered_mysql2_connection(raw_config)
       config = raw_config.symbolize_keys
-      config[:flags] ||= 0
 
-      if config[:flags].kind_of? Array
-        config[:flags].push "FOUND_ROWS"
-      else
-        config[:flags] |= Mysql2::Client::FOUND_ROWS
-      end
       config[:username] = 'root' if config[:username].nil?
+      config[:flags]    = Mysql2::Client::FOUND_ROWS if Mysql2::Client.const_defined?(:FOUND_ROWS)
 
-      client = FiberedMysql2Adapter.new_client(config)
-      FiberedMysql2Adapter.new(client, logger, nil, config)
+      client =
+          begin
+            Mysql2::Client.new(config)
+          rescue Mysql2::Error => error
+            if error.message.include?("Unknown database")
+              raise ActiveRecord::NoDatabaseError.new(error.message)
+            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

data/lib/fibered_mysql2/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FiberedMysql2
-  VERSION = "0.4.0.pre.tstarck.3"
+  VERSION = "1.0.0.colin.1"
 end

data/lib/fibered_mysql2.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
+require 'async'
 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'
-require_relative 'fibered_mysql2/hash_config_override'
 
 module FiberedMysql2
   class Error < StandardError; end

metadata

@@ -1,49 +1,49 @@
 --- !ruby/object:Gem::Specification
 name: fibered_mysql2
 version: !ruby/object:Gem::Version
-  version: 0.4.0.pre.tstarck.3
+  version: 1.0.0.colin.1
 platform: ruby
 authors:
 - Invoca Development
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-08-06 00:00:00.000000000 Z
+date: 2023-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: em-synchrony
+  name: async
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.0'
+        version: '5.2'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '7.2'
+        version: '7'
 description:
 email:
 - development@invoca.com
@@ -51,6 +51,7 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/CODEOWNERS"
 - ".github/workflows/build.yml"
 - ".github/workflows/release.yml"
 - ".gitignore"
@@ -65,15 +66,14 @@ files:
 - bin/console
 - bin/setup
 - fibered_mysql2.gemspec
-- gemfiles/.bundle/config
-- gemfiles/rails_7_0.gemfile
-- gemfiles/rails_7_1.gemfile
+- gemfiles/rails_5.gemfile
+- gemfiles/rails_6.gemfile
 - lib/active_record/connection_adapters/fibered_mysql2_adapter.rb
 - lib/fibered_mysql2.rb
+- lib/fibered_mysql2/async_task.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/hash_config_override.rb
 - lib/fibered_mysql2/version.rb
 homepage: https://github.com/Invoca/fibered_mysql2
 licenses: []
@@ -91,11 +91,11 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.5.22
+rubygems_version: 3.4.6
 signing_key:
 specification_version: 4
 summary: An adapter for fibered mysql2

data/gemfiles/.bundle/config

@@ -1,2 +0,0 @@
----
-BUNDLE_RETRY: "1"