activerecord-mysql-reconnect 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9ac7822c0f663ad7cf90036be1093e185b6a7510
-  data.tar.gz: 0e47d5cf1f48399f9f120d7596206521ba91be5d
+  metadata.gz: 22681715c79fdec28b4dcffd8a5f1e73a9c45f71
+  data.tar.gz: 977d88bd69f012e89270b17730da3312031966eb
 SHA512:
-  metadata.gz: 3e02a754713686f67ef46dddb0091c34caf7b43b596048ed5f83543f13093d61dfd5774dad7010a163a9e48474760736a4bec063b1424f6b13b2a95beb50c93b
-  data.tar.gz: 62edd5b7910a1723d334e91bab60e89ffb3f70c2c2886ffae06cee0857c123efb66786652ad73e2d0f67f0dd403acd87c50352b5c7b5cc677c720161d9276366
+  metadata.gz: febba5eaf59e2e0704c1b5dbaf47d4b5ab43eafd93de02eaafb6d5bec8edb1b805666cff5524c70851d6905bdfc2bafb0d9598e0c9a9bf3233f2a50bd4e56145
+  data.tar.gz: 104afd1d2871e16ce7885aa9b236af13906a40bd7b833737d7d24c37731d844b7df9b06ff2773683e0c78841cece01e8e907d5300444f7f9cc3fe3906c88b355

data/README.md

@@ -74,10 +74,31 @@ ActiveRecord::Base.retryable_transaction do
 end
 ```
 
-## Running tests
+## Use on rails
+
+### Gemfile
+
+```ruby
+gem 'activerecord-mysql-reconnect'
+```
+
+### environment file
+
+```ruby
+MyApp::Application.configure do
+  ...
+  config.active_record.execution_tries = 10 # times
+  config.active_record.execution_retry_wait = 1.5 # sec
+  ...
+ene
+```
+
+## Running tests on local
 
 ```sh
 mysql.server start
+export ACTIVERECORD_MYSQL_RECONNECT_MYSQL_START='mysql.server start'
+export ACTIVERECORD_MYSQL_RECONNECT_MYSQL_STOP='mysql.server stop'
 export ACTIVERECORD_MYSQL_RECONNECT_MYSQL_RESTART='mysql.server restart'
 bundle install
 bundle exec rake

data/lib/activerecord/mysql/reconnect/abstract_adapter_ext.rb

@@ -0,0 +1,3 @@
+class ActiveRecord::ConnectionAdapters::AbstractAdapter
+  # XXX:
+end

data/lib/activerecord/mysql/reconnect/abstract_mysql_adapter_ext.rb

@@ -0,0 +1,57 @@
+class ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
+  def execute_with_reconnect(sql, name = nil)
+    retryable(sql, name) do |sql_names|
+      retval = nil
+
+      sql_names.each do |s, n|
+        retval = execute_without_reconnect(s, n)
+      end
+
+      add_sql_to_transaction(sql, name)
+      retval
+    end
+  end
+
+  alias_method_chain :execute, :reconnect
+
+  private
+
+  def retryable(sql, name, &block)
+    block_with_reconnect = nil
+    sql_names = [[sql, name]]
+    orig_transaction = @transaction
+
+    Activerecord::Mysql::Reconnect.retryable(
+      :proc => proc {
+        (block_with_reconnect || block).call(sql_names)
+      },
+      :on_error => proc {
+        unless block_with_reconnect
+          block_with_reconnect = proc do |i|
+            reconnect_without_retry!
+            @transaction = orig_transaction if orig_transaction
+            block.call(i)
+          end
+        end
+
+        sql_names = merge_transaction(sql, name)
+      }
+    )
+  end
+
+  def add_sql_to_transaction(sql, name)
+    if (buf = Activerecord::Mysql::Reconnect.retryable_transaction_buffer)
+      buf << [sql, name]
+    end
+  end
+
+  def merge_transaction(sql, name)
+    sql_name = [sql, name]
+
+    if (buf = Activerecord::Mysql::Reconnect.retryable_transaction_buffer)
+      buf + [sql_name]
+    else
+      [sql_name]
+    end
+  end
+end

data/lib/activerecord/mysql/reconnect/base_ext.rb

@@ -0,0 +1,18 @@
+class ActiveRecord::Base
+  class_attribute :execution_tries, :instance_writer => false
+  class_attribute :execution_retry_wait, :instance_writer => false
+
+  class << self
+    def without_retry
+      Activerecord::Mysql::Reconnect.without_retry do
+        yield
+      end
+    end
+
+    def retryable_transaction
+      Activerecord::Mysql::Reconnect.retryable_transaction do
+        yield
+      end
+    end
+  end
+end

data/lib/activerecord/mysql/reconnect/connection_pool_ext.rb

@@ -0,0 +1,11 @@
+class ActiveRecord::ConnectionAdapters::ConnectionPool
+  def new_connection_with_retry
+    Activerecord::Mysql::Reconnect.retryable(
+      :proc => proc {
+        new_connection_without_retry
+      }
+    )
+  end
+
+  alias_method_chain :new_connection, :retry
+end

data/lib/activerecord/mysql/reconnect/mysql2_adapter_ext.rb

@@ -0,0 +1,11 @@
+class ActiveRecord::ConnectionAdapters::Mysql2Adapter
+  def reconnect_with_retry!
+    Activerecord::Mysql::Reconnect.retryable(
+      :proc => proc {
+        reconnect_without_retry!
+      }
+    )
+  end
+
+  alias_method_chain :reconnect!, :retry
+end

data/lib/activerecord/mysql/reconnect/version.rb

@@ -1,7 +1,7 @@
 module Activerecord
   module Mysql
     module Reconnect
-      VERSION = '0.1.1'
+      VERSION = '0.2.0'
     end
   end
 end

data/lib/activerecord/mysql/reconnect.rb

@@ -1,2 +1,129 @@
+require 'mysql2'
+require 'logger'
+
+require 'active_record'
+require 'active_record/base'
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/abstract_mysql_adapter'
+require 'active_record/connection_adapters/mysql2_adapter'
+require 'active_record/connection_adapters/abstract/connection_pool'
+require 'active_support'
+
 require 'activerecord/mysql/reconnect/version'
-require 'activerecord/mysql/reconnect/abstract_mysql_adapter'
+require 'activerecord/mysql/reconnect/base_ext'
+require 'activerecord/mysql/reconnect/abstract_adapter_ext'
+require 'activerecord/mysql/reconnect/abstract_mysql_adapter_ext'
+require 'activerecord/mysql/reconnect/mysql2_adapter_ext'
+require 'activerecord/mysql/reconnect/connection_pool_ext'
+
+module Activerecord::Mysql::Reconnect
+  DEFAULT_EXECUTION_TRIES = 3
+  DEFAULT_EXECUTION_RETRY_WAIT = 0.5
+
+  WITHOUT_RETRY_KEY = 'activerecord-mysql-reconnect-without-retry'
+  RETRYABLE_TRANSACTION_KEY = 'activerecord-mysql-reconnect-transaction-retry'
+
+  HANDLE_ERROR = [
+    ActiveRecord::StatementInvalid,
+    Mysql2::Error,
+  ]
+
+  HANDLE_ERROR_MESSAGES = [
+    'MySQL server has gone away',
+    'Server shutdown in progress',
+    'closed MySQL connection',
+    "Can't connect to MySQL server",
+    'Query execution was interrupted',
+    'Access denied for user',
+    'Lost connection to MySQL server during query',
+  ]
+
+  class << self
+    def execution_tries
+      ActiveRecord::Base.execution_tries || DEFAULT_EXECUTION_TRIES
+    end
+
+    def execution_retry_wait
+      ActiveRecord::Base.execution_retry_wait || DEFAULT_EXECUTION_RETRY_WAIT
+    end
+
+    def retryable(opts)
+      block = opts.fetch(:proc)
+      on_error = opts[:on_error]
+      tries = self.execution_tries
+      retval = nil
+
+      retryable_loop(tries) do |n|
+        begin
+          retval = block.call
+          break
+        rescue => e
+          if (tries.zero? or n < tries) and should_handle?(e)
+            on_error.call if on_error
+            wait = self.execution_retry_wait * n
+            logger.warn("MySQL server has gone away. Trying to reconnect in #{wait} seconds. (cause: #{e} [#{e.class}])")
+            sleep(wait)
+            next
+          else
+            raise e
+          end
+        end
+      end
+
+      return retval
+    end
+
+    def logger
+      if defined?(Rails)
+        Rails.logger || ActiveRecord::Base.logger || Logger.new($stderr)
+      else
+        ActiveRecord::Base.logger || Logger.new($stderr)
+      end
+    end
+
+    def without_retry
+      begin
+        Thread.current[WITHOUT_RETRY_KEY] = true
+        yield
+      ensure
+        Thread.current[WITHOUT_RETRY_KEY] = nil
+      end
+    end
+
+    def without_retry?
+      !!Thread.current[WITHOUT_RETRY_KEY]
+    end
+
+    def retryable_transaction
+      begin
+        Thread.current[RETRYABLE_TRANSACTION_KEY] = []
+
+        ActiveRecord::Base.transaction do
+          yield
+        end
+      ensure
+        Thread.current[RETRYABLE_TRANSACTION_KEY] = nil
+      end
+    end
+
+    def retryable_transaction_buffer
+      Thread.current[RETRYABLE_TRANSACTION_KEY]
+    end
+
+    private
+
+    def retryable_loop(n)
+      if n.zero?
+        loop { n += 1 ; yield(n) }
+      else
+        n.times {|i| yield(i + 1) }
+      end
+    end
+
+    def should_handle?(e)
+      !without_retry? &&
+      HANDLE_ERROR.any? {|i| e.kind_of?(i) } &&
+      Regexp.union(HANDLE_ERROR_MESSAGES) =~ e.message
+    end
+  end # end of class methods
+end

data/spec/{activerecord/mysql/reconnect_spec.rb → activerecord-mysql-reconnect_spec.rb}

@@ -165,4 +165,52 @@ describe 'activerecord-mysql-reconnect' do
       expect(Employee.count).to eq(300027)
     }.to_not raise_error
   end
+
+  it 'retry new connection' do
+    expect {
+      ActiveRecord::Base.clear_all_connections!
+      mysql_restart
+      expect(Employee.count).to eq(300024)
+    }.to_not raise_error
+  end
+
+  it 'retry verify' do
+    expect {
+      thread_running = false
+
+      th = Thread.start {
+        thread_running = true
+        mysql_stop
+        sleep 15
+        mysql_start
+        thread_running = false
+      }
+
+      th.abort_on_exception = true
+      sleep 3
+      expect(thread_running).to be_true
+      ActiveRecord::Base.connection.verify!
+      th.join
+    }.to_not raise_error
+  end
+
+  it 'retry reconnect' do
+    expect {
+      thread_running = false
+
+      th = Thread.start {
+        thread_running = true
+        mysql_stop
+        sleep 15
+        mysql_start
+        thread_running = false
+      }
+
+      th.abort_on_exception = true
+      sleep 3
+      expect(thread_running).to be_true
+      ActiveRecord::Base.connection.reconnect!
+      th.join
+    }.to_not raise_error
+  end
 end

data/spec/spec_helper.rb

@@ -3,6 +3,16 @@ require 'mysql2'
 
 class Employee < ActiveRecord::Base; end
 
+def mysql_start
+  cmd = ENV['ACTIVERECORD_MYSQL_RECONNECT_MYSQL_START'] || 'sudo /etc/init.d/mysql start'
+  system(cmd)
+end
+
+def mysql_stop
+  cmd = ENV['ACTIVERECORD_MYSQL_RECONNECT_MYSQL_STOP'] || 'sudo /etc/init.d/mysql stop'
+  system(cmd)
+end
+
 def mysql_restart
   cmd = ENV['ACTIVERECORD_MYSQL_RECONNECT_MYSQL_RESTART'] || 'sudo /etc/init.d/mysql restart'
   system(cmd)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-mysql-reconnect
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Genki Sugawara
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-03 00:00:00.000000000 Z
+date: 2014-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -96,9 +96,13 @@ files:
 - Rakefile
 - activerecord-mysql-reconnect.gemspec
 - lib/activerecord/mysql/reconnect.rb
-- lib/activerecord/mysql/reconnect/abstract_mysql_adapter.rb
+- lib/activerecord/mysql/reconnect/abstract_adapter_ext.rb
+- lib/activerecord/mysql/reconnect/abstract_mysql_adapter_ext.rb
+- lib/activerecord/mysql/reconnect/base_ext.rb
+- lib/activerecord/mysql/reconnect/connection_pool_ext.rb
+- lib/activerecord/mysql/reconnect/mysql2_adapter_ext.rb
 - lib/activerecord/mysql/reconnect/version.rb
-- spec/activerecord/mysql/reconnect_spec.rb
+- spec/activerecord-mysql-reconnect_spec.rb
 - spec/employees.sql
 - spec/spec_helper.rb
 homepage: https://bitbucket.org/winebarrel/activerecord-mysql-reconnect
@@ -127,6 +131,6 @@ specification_version: 4
 summary: It is the library to reconnect automatically when ActiveRecord is disconnected
   from MySQL.
 test_files:
-- spec/activerecord/mysql/reconnect_spec.rb
+- spec/activerecord-mysql-reconnect_spec.rb
 - spec/employees.sql
 - spec/spec_helper.rb

data/lib/activerecord/mysql/reconnect/abstract_mysql_adapter.rb

@@ -1,131 +0,0 @@
-require 'active_record'
-require 'active_record/connection_adapters/abstract_mysql_adapter'
-require 'active_support'
-require 'mysql2'
-require 'logger'
-
-class ActiveRecord::Base
-  class_attribute :execution_tries
-  class_attribute :execution_retry_wait
-
-  class << self
-    def without_retry
-      begin
-        Thread.current[ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::WITHOUT_RETRY_KEY] = true
-        yield
-      ensure
-        Thread.current[ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::WITHOUT_RETRY_KEY] = nil
-      end
-    end
-
-    def retryable_transaction
-      begin
-        Thread.current[ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::RETRYABLE_TRANSACTION_KEY] = []
-
-        ActiveRecord::Base.transaction do
-          yield
-        end
-      ensure
-        Thread.current[ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter::RETRYABLE_TRANSACTION_KEY] = nil
-      end
-    end
-  end
-end
-
-class ActiveRecord::ConnectionAdapters::AbstractMysqlAdapter
-  DEFAULT_EXECUTION_TRIES = 3
-  DEFAULT_EXECUTION_RETRY_WAIT = 0.5
-
-  ERROR_MESSAGES = [
-    'MySQL server has gone away',
-    'Server shutdown in progress',
-    'closed MySQL connection',
-    "Can't connect to MySQL server",
-    'Query execution was interrupted',
-  ]
-
-  WITHOUT_RETRY_KEY = 'activerecord-mysql-reconnect-without-retry'
-  RETRYABLE_TRANSACTION_KEY = 'activerecord-mysql-reconnect-transaction-retry'
-
-  def execute_with_reconnect(sql, name = nil)
-    retryable(sql, name) do |sql_names|
-      retval = nil
-
-      sql_names.each do |s, n|
-        retval = execute_without_reconnect(s, n)
-      end
-
-      add_sql_to_transaction(sql, name)
-      retval
-    end
-  end
-
-  alias_method_chain :execute, :reconnect
-
-  private
-
-  def retryable(sql, name, &block)
-    tries = ActiveRecord::Base.execution_tries || DEFAULT_EXECUTION_TRIES
-    logger = ActiveRecord::Base.logger || Logger.new($stderr)
-    block_with_reconnect = nil
-    retval = nil
-    sql_names = [[sql, name]]
-    orig_transaction = @transaction
-
-    retryable_loop(tries) do |n|
-      begin
-        retval = (block_with_reconnect || block).call(sql_names)
-        break
-      rescue ActiveRecord::StatementInvalid, Mysql2::Error => e
-        if not without_retry? and (tries.zero? or n < tries) and e.message =~ Regexp.union(ERROR_MESSAGES)
-          unless block_with_reconnect
-            block_with_reconnect = proc do |i|
-              reconnect!
-              @transaction = orig_transaction if orig_transaction
-              block.call(i)
-            end
-          end
-
-          sql_names = merge_transaction(sql, name)
-          wait = (ActiveRecord::Base.execution_retry_wait || DEFAULT_EXECUTION_RETRY_WAIT) * n
-          logger.warn("MySQL server has gone away. Trying to reconnect in #{wait} seconds. (cause: #{e} [#{e.class}])")
-          sleep(wait)
-
-          next
-        else
-          raise e
-        end
-      end
-    end
-
-    return retval
-  end
-
-  def retryable_loop(n)
-    if n.zero?
-      loop { n += 1 ; yield(n) }
-    else
-      n.times {|i| yield(i + 1) }
-    end
-  end
-
-  def without_retry?
-    !!Thread.current[WITHOUT_RETRY_KEY]
-  end
-
-  def add_sql_to_transaction(sql, name)
-    if (buf = Thread.current[RETRYABLE_TRANSACTION_KEY])
-      buf << [sql, name]
-    end
-  end
-
-  def merge_transaction(sql, name)
-    sql_name = [sql, name]
-
-    if (buf = Thread.current[RETRYABLE_TRANSACTION_KEY])
-      buf + [sql_name]
-    else
-      [sql_name]
-    end
-  end
-end