activerecord-mysql-reconnect 0.0.1 → 0.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    YjQ4MjM5ZDVlNmU3OWY3YTc4OGZjZGFhNjM4ZDgyYjM3YjZmM2I1Yg==
-  data.tar.gz: !binary |-
-    ZGJkZjJmZDJkNDA4OWVhY2EzOTZjOGEzYzVlMDkyNzJjZDY5MzZiOA==
+SHA1:
+  metadata.gz: 4dc078edb058b76e0a2608757ee28874723e17b0
+  data.tar.gz: 3ce76b372e6dcc6c0ea9a1d3c92852376671aa86
 SHA512:
-  metadata.gz: !binary |-
-    MTBkOTJmOGU1ZTU5YWNmNjk4NTU1ZTRlMjE5YjM3ZTkxZjZhNjY2MjEwZjU1
-    NzNlMGU2MGZjYjVlZDU1MmFhYjFiNTQ5ZmI1OGZlZmRhZjRmMjI4ZDg5M2Jm
-    YmZiYzMwMzcwNmEyZmY2Y2M0NTkwN2IxOWY5NWE1MGNiNjQ1Mzk=
-  data.tar.gz: !binary |-
-    M2ZmNjNmNjdlMTg2YzcwZTU0OWJiMWU2ZThkMWUwYThiNzNmMmI5ZGZkNzIy
-    MzNjNjc3NTZkOTg2MjY2M2RjZmFmZjAyYmE0Y2IxMDNjYzE2OWE3ZjYxNDZk
-    MzUzNWE3YzE3NDQyNmFmNjY1OWI1ODhmMTE2MWQzMThmOGQyYTA=
+  metadata.gz: f026083fd7126a3910045110d0fb697b004667eef51ad4bbaa201256ecdd8b216b1ba11401b19faa730e4a0f7bc2207ff11d62e25eb0c5c0c0508f942d2ee1d9
+  data.tar.gz: b0a162b084442e8fc6990f736f55cfedd5c36fb620403fbe3b1ec8351b8a5bf36b69058dc1564051474f14aec4da8667341e45ee8c0cc7acbe5295f1cfe9ab52

data/.gitignore

@@ -15,3 +15,4 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+test.rb

data/.rspec

@@ -0,0 +1,2 @@
+--require spec_helper
+--colour

data/README.md

@@ -1,7 +1,10 @@
-# Activerecord::Mysql::Reconnect
+# activerecord-mysql-reconnect
 
 It is the library to reconnect automatically when ActiveRecord is disconnected from MySQL.
 
+[![Gem Version](https://badge.fury.io/rb/activerecord-mysql-reconnect.png)](http://badge.fury.io/rb/activerecord-mysql-reconnect)
+[![Build Status](https://drone.io/bitbucket.org/winebarrel/activerecord-mysql-reconnect/status.png)](https://drone.io/bitbucket.org/winebarrel/activerecord-mysql-reconnect/latest)
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -19,8 +22,6 @@ Or install it yourself as:
 ## Usage
 
 ```ruby
-#!/usr/bin/env ruby
-require 'active_record'
 require 'activerecord/mysql/reconnect'
 require 'logger'
 
@@ -28,7 +29,7 @@ ActiveRecord::Base.establish_connection(
   adapter:  'mysql2',
   host:     '127.0.0.1',
   username: 'root',
-  database: 'test',
+  database: 'employees',
 )
 
 ActiveRecord::Base.logger = Logger.new($stdout)
@@ -55,6 +56,29 @@ MySQL server has gone away. Trying to reconnect in 0.5 seconds.
 300024
 ```
 
-## Link
+### without_retry
+
+```ruby
+ActiveRecord::Base.without_retry do
+  Employee.count
+end
+```
+
+### retryable_transaction
 
-* [RubyGems.org site](http://rubygems.org/gems/activerecord-mysql-reconnect)
+```ruby
+ActiveRecord::Base.retryable_transaction do
+  Employee.create(emp_no: 1, birth_date: Time.now, first_name: 'Scott', last_name: 'Tiger', hire_date: Time.now)
+  Employee.create(emp_no: 2, birth_date: Time.now, first_name: 'Scott', last_name: 'Tiger', hire_date: Time.now)
+  Employee.create(emp_no: 3, birth_date: Time.now, first_name: 'Scott', last_name: 'Tiger', hire_date: Time.now)
+end
+```
+
+## Running tests
+
+```sh
+mysql.server start
+export ACTIVERECORD_MYSQL_RECONNECT_MYSQL_RESTART='mysql.server restart'
+bundle install
+bundle exec rake
+```

data/Rakefile

@@ -1 +1,5 @@
-require "bundler/gem_tasks"
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+task :default => :spec

data/activerecord-mysql-reconnect.gemspec

@@ -4,22 +4,23 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'activerecord/mysql/reconnect/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "activerecord-mysql-reconnect"
+  spec.name          = 'activerecord-mysql-reconnect'
   spec.version       = Activerecord::Mysql::Reconnect::VERSION
-  spec.authors       = ["Genki Sugawara"]
-  spec.email         = ["sugawara@cookpad.com"]
+  spec.authors       = ['Genki Sugawara']
+  spec.email         = ['sugawara@cookpad.com']
   spec.description   = %q{It is the library to reconnect automatically when ActiveRecord is disconnected from MySQL.}
-  spec.summary       = %q{It is the library to reconnect automatically when ActiveRecord is disconnected from MySQL.}
-  spec.homepage      = "https://bitbucket.org/winebarrel/activerecord-mysql-reconnect"
-  spec.license       = "MIT"
+  spec.summary       = spec.description
+  spec.homepage      = 'https://bitbucket.org/winebarrel/activerecord-mysql-reconnect'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files`.split($/)
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_dependency "activerecord", "~> 3.2.14"
-  spec.add_dependency "retryable", "~> 1.3.3"
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.add_dependency 'activerecord', '~> 3.2.14'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 2.14.1'
+  spec.add_development_dependency 'mysql2'
 end

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

@@ -1,35 +1,125 @@
 require 'active_record'
 require 'active_record/connection_adapters/abstract_mysql_adapter'
 require 'active_support'
-require 'retryable'
+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
-  MYSQL_SERVER_HAS_GONE_AWAY = 'MySQL server has gone away'
-  DEFAULT_EXECUTION_TRIES = 1
+  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_options = {
-      :tries    => (ActiveRecord::Base.execution_tries || DEFAULT_EXECUTION_TRIES),
-      :matching => /#{MYSQL_SERVER_HAS_GONE_AWAY}/,
-      :sleep    => proc {|n|
-        wait = (ActiveRecord::Base.execution_retry_wait || DEFAULT_EXECUTION_RETRY_WAIT) * (n + 1)
-        logger.warn("#{MYSQL_SERVER_HAS_GONE_AWAY}. Trying to reconnect in #{wait} seconds.")
-        sleep(wait)
-        reconnect!
-        0
-      }
-    }
- 
-    retryable(retryable_options) do
-      execute_without_reconnect(sql, name)
+    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]]
+
+    retryable_loop(tries) do |n|
+      begin
+        retval = (block_with_reconnect || block).call(sql_names)
+        break
+      rescue => 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 {|i| reconnect! ; block.call(i) }
+          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

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

@@ -1,7 +1,7 @@
 module Activerecord
   module Mysql
     module Reconnect
-      VERSION = "0.0.1"
+      VERSION = '0.1.0'
     end
   end
 end

data/spec/activerecord/mysql/reconnect_spec.rb

@@ -0,0 +1,168 @@
+describe Hash do
+  it 'select all' do
+    expect {
+      expect(Employee.all.length).to eq(300024)
+      mysql_restart
+      expect(Employee.all.length).to eq(300024)
+    }.to_not raise_error
+  end
+
+  it 'count' do
+    expect {
+      expect(Employee.count).to eq(300024)
+      mysql_restart
+      expect(Employee.count).to eq(300024)
+    }.to_not raise_error
+  end
+
+  it 'on select' do
+    expect {
+      thread_running = false
+
+      th = Thread.start {
+        thread_running = true
+        expect(Employee.where(:id => 1).pluck('sleep(15)')).to eq([1])
+        thread_running = false
+      }
+
+      th.abort_on_exception = true
+      sleep 3
+      expect(thread_running).to be_true
+      mysql_restart
+      expect(Employee.count).to be >= 300024
+      th.join
+    }.to_not raise_error
+  end
+
+  it 'on insert' do
+    expect {
+      thread_running = false
+
+      th = Thread.start {
+        thread_running = true
+        emp = Employee.create(
+                :emp_no     => 1,
+                :birth_date => Time.now,
+                :first_name => "' + sleep(15) + '",
+                :last_name  => 'Tiger',
+                :hire_date  => Time.now
+              )
+        thread_running = false
+        expect(emp.id).to eq(300025)
+        expect(emp.emp_no).to eq(1)
+      }
+
+      th.abort_on_exception = true
+      sleep 3
+      expect(thread_running).to be_true
+      mysql_restart
+      expect(Employee.count).to be >= 300024
+      th.join
+    }.to_not raise_error
+  end
+
+  it 'op update' do
+    expect {
+      thread_running = false
+
+      th = Thread.start {
+        thread_running = true
+        emp = Employee.where(:id => 1).first
+        emp.first_name = "' + sleep(15) + '"
+        emp.last_name = 'ZapZapZap'
+        emp.save!
+        thread_running = false
+
+        emp = Employee.where(:id => 1).first
+        expect(emp.last_name).to eq('ZapZapZap')
+      }
+
+      th.abort_on_exception = true
+      sleep 3
+      expect(thread_running).to be_true
+      mysql_restart
+      expect(Employee.count).to eq(300024)
+      th.join
+    }.to_not raise_error
+  end
+
+  it 'without_retry' do
+    expect {
+      ActiveRecord::Base.without_retry do
+        Employee.count
+        mysql_restart
+        Employee.count
+      end
+    }.to raise_error(ActiveRecord::StatementInvalid)
+  end
+
+  it 'transaction' do
+    expect {
+      expect(Employee.count).to eq(300024)
+
+      ActiveRecord::Base.transaction do
+        emp = Employee.create(
+                :emp_no     => 1,
+                :birth_date => Time.now,
+                :first_name => 'Scott',
+                :last_name  => 'Tiger',
+                :hire_date  => Time.now
+              )
+        expect(emp.id).to eq(300025)
+        expect(emp.emp_no).to eq(1)
+        mysql_restart
+        emp = Employee.create(
+                :emp_no     => 2,
+                :birth_date => Time.now,
+                :first_name => 'Scott',
+                :last_name  => 'Tiger',
+                :hire_date  => Time.now
+              )
+        expect(emp.id).to eq(300025)
+        expect(emp.emp_no).to eq(2)
+      end
+
+      expect(Employee.count).to eq(300025)
+    }.to_not raise_error
+  end
+
+  it 'retryable_transaction' do
+    expect {
+      expect(Employee.count).to eq(300024)
+
+      ActiveRecord::Base.retryable_transaction do
+        emp = Employee.create(
+                :emp_no     => 1,
+                :birth_date => Time.now,
+                :first_name => 'Scott',
+                :last_name  => 'Tiger',
+                :hire_date  => Time.now
+              )
+        expect(emp.id).to eq(300025)
+        expect(emp.emp_no).to eq(1)
+        mysql_restart
+        emp = Employee.create(
+                :emp_no     => 2,
+                :birth_date => Time.now,
+                :first_name => 'Scott',
+                :last_name  => 'Tiger',
+                :hire_date  => Time.now
+              )
+        expect(emp.id).to eq(300026)
+        expect(emp.emp_no).to eq(2)
+        mysql_restart
+        emp = Employee.create(
+                :emp_no     => 3,
+                :birth_date => Time.now,
+                :first_name => 'Scott',
+                :last_name  => 'Tiger',
+                :hire_date  => Time.now
+              )
+        expect(emp.id).to eq(300027)
+        expect(emp.emp_no).to eq(3)
+      end
+
+      expect(Employee.count).to eq(300027)
+    }.to_not raise_error
+  end
+end