lhm-shopify 3.3.5

data/spec/integration/lock_wait_timeout_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+
+describe Lhm do
+  include IntegrationHelper
+
+  before(:each) do
+    connect_master!
+    table_create(:users)
+  end
+
+  it 'set_session_lock_wait_timeouts should set the sessions lock wait timeouts to less than the global values by a delta' do
+    connection = Lhm.send(:connection)
+    connection.execute('SET GLOBAL innodb_lock_wait_timeout=11')
+    connection.execute('SET GLOBAL lock_wait_timeout=11')
+    connection.execute('SET SESSION innodb_lock_wait_timeout=1')
+    connection.execute('SET SESSION lock_wait_timeout=1')
+
+    global_innodb_lock_wait_timeout = connection.select_one("SHOW GLOBAL VARIABLES LIKE 'innodb_lock_wait_timeout'")['Value'].to_i
+    global_lock_wait_timeout = connection.select_one("SHOW GLOBAL VARIABLES LIKE 'lock_wait_timeout'")['Value'].to_i
+
+    invoker = Lhm::Invoker.new(Lhm::Table.parse(:users, connection), connection)
+    invoker.set_session_lock_wait_timeouts
+
+    session_innodb_lock_wait_timeout = connection.select_one("SHOW SESSION VARIABLES LIKE 'innodb_lock_wait_timeout'")['Value'].to_i
+    session_lock_wait_timeout = connection.select_one("SHOW SESSION VARIABLES LIKE 'lock_wait_timeout'")['Value'].to_i
+
+    session_lock_wait_timeout.must_equal global_lock_wait_timeout + Lhm::Invoker::LOCK_WAIT_TIMEOUT_DELTA
+    session_innodb_lock_wait_timeout.must_equal global_innodb_lock_wait_timeout + Lhm::Invoker::LOCK_WAIT_TIMEOUT_DELTA
+  end
+end

data/spec/integration/locked_switcher_spec.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+
+require 'lhm/table'
+require 'lhm/migration'
+require 'lhm/locked_switcher'
+
+describe Lhm::LockedSwitcher do
+  include IntegrationHelper
+
+  before(:each) do
+    connect_master!
+    @old_logger = Lhm.logger
+    Lhm.logger = Logger.new('/dev/null')
+  end
+
+  after(:each) do
+    Lhm.logger = @old_logger
+  end
+
+  describe 'switching' do
+    before(:each) do
+      @origin = table_create('origin')
+      @destination = table_create('destination')
+      @migration = Lhm::Migration.new(@origin, @destination)
+    end
+
+    it 'rename origin to archive' do
+      switcher = Lhm::LockedSwitcher.new(@migration, connection)
+      switcher.run
+
+      slave do
+        data_source_exists?(@origin).must_equal true
+        table_read(@migration.archive_name).columns.keys.must_include 'origin'
+      end
+    end
+
+    it 'rename destination to origin' do
+      switcher = Lhm::LockedSwitcher.new(@migration, connection)
+      switcher.run
+
+      slave do
+        data_source_exists?(@destination).must_equal false
+        table_read(@origin.name).columns.keys.must_include 'destination'
+      end
+    end
+  end
+end

data/spec/integration/sql_retry/lock_wait_spec.rb

@@ -0,0 +1,125 @@
+require 'minitest/autorun'
+require 'mysql2'
+require 'integration/sql_retry/lock_wait_timeout_test_helper'
+require 'lhm'
+
+describe Lhm::SqlRetry do
+  before(:each) do
+    @old_logger = Lhm.logger
+    @logger = StringIO.new
+    Lhm.logger = Logger.new(@logger)
+
+    @helper = LockWaitTimeoutTestHelper.new(
+      lock_duration: 5,
+      innodb_lock_wait_timeout: 2
+    )
+
+    @helper.create_table_to_lock
+
+    # Start a thread to hold a lock on the table
+    @locked_record_id = @helper.hold_lock
+
+    # Assert our pre-conditions
+    assert_equal 2, @helper.record_count
+  end
+
+  after(:each) do
+    # Restore default logger
+    Lhm.logger = @old_logger
+  end
+
+  # This is the control test case. It shows that when Lhm::SqlRetry is not used,
+  # a lock wait timeout exceeded error is raised.
+  it "does nothing to prevent exceptions, when not used" do
+    puts ""
+    puts "***The output you see below is OK so long as the test passes.***"
+    puts "*" * 64
+    # Start a thread to retry, once the lock is held, execute the block
+    @helper.with_waiting_lock do |waiting_connection|
+      @helper.insert_records_at_ids(waiting_connection, [@locked_record_id])
+    end
+
+    exception = assert_raises { @helper.trigger_wait_lock }
+
+    assert_equal "Lock wait timeout exceeded; try restarting transaction", exception.message
+    assert_equal Mysql2::Error::TimeoutError, exception.class
+
+    assert_equal 2, @helper.record_count # no records inserted
+    puts "*" * 64
+  end
+
+  # This is test demonstrating the happy path: a well configured retry
+  # tuned to the locks it encounters.
+  it "successfully executes the SQL despite the errors encountered" do
+    # Start a thread to retry, once the lock is held, execute the block
+    @helper.with_waiting_lock do |waiting_connection|
+      sql_retry = Lhm::SqlRetry.new(waiting_connection, {
+        base_interval: 0.2, # first retry after 200ms
+        multiplier: 1, # subsequent retries wait 1x longer than first retry (no change)
+        tries: 3, # we only need 3 tries (including the first) for the scenario described below
+        rand_factor: 0 # do not introduce randomness to wait timer
+      })
+
+      # RetryTestHelper is configured to hold lock for 5 seconds and timeout after 2 seconds.
+      # Therefore the sequence of events will be:
+      # 0s:   first insert query is started while lock is held
+      # 2s:   first timeout error will occur, SqlRetry is configured to wait 200ms after this
+      # 2.2s: second insert query is started while lock is held
+      # 4.2s: second timeout error will occur, SqlRetry is configured to wait 200ms after this
+      # 4.4s: third insert query is started while lock is held
+      # 5s:   lock is released, insert successful no further retries needed
+      sql_retry.with_retries do |retriable_connection|
+        @helper.insert_records_at_ids(retriable_connection, [@locked_record_id])
+      end
+    end
+
+    @helper.trigger_wait_lock
+
+    assert_equal 3, @helper.record_count # records inserted successfully despite lock
+
+    logs = @logger.string.split("\n")
+    assert_equal 2, logs.length
+
+    assert logs.first.include?("Mysql2::Error::TimeoutError: 'Lock wait timeout exceeded; try restarting transaction' - 1 tries")
+    assert logs.first.include?("0.2 seconds until the next try")
+
+    assert logs.last.include?("Mysql2::Error::TimeoutError: 'Lock wait timeout exceeded; try restarting transaction' - 2 tries")
+    assert logs.last.include?("0.2 seconds until the next try")
+  end
+
+  # This is test demonstrating the sad configuration path: it shows
+  # that when the retries are not tuned to the locks encountered,
+  # retries are not effective.
+  it "fails to retry enough to overcome the timeout" do
+    puts ""
+    puts "***The output you see below is OK so long as the test passes.***"
+    puts "*" * 64
+    # Start a thread to retry, once the lock is held, execute the block
+    @helper.with_waiting_lock do |waiting_connection|
+      sql_retry = Lhm::SqlRetry.new(waiting_connection, {
+        base_interval: 0.2, # first retry after 200ms
+        multiplier: 1, # subsequent retries wait 1x longer than first retry (no change)
+        tries: 2, # we need 3 tries (including the first) for the scenario described below, but we only get two...we will fail
+        rand_factor: 0 # do not introduce randomness to wait timer
+      })
+
+      # RetryTestHelper is configured to hold lock for 5 seconds and timeout after 2 seconds.
+      # Therefore the sequence of events will be:
+      # 0s:   first insert query is started while lock is held
+      # 2s:   first timeout error will occur, SqlRetry is configured to wait 200ms after this
+      # 2.2s: second insert query is started while lock is held
+      # 4.2s: second timeout error will occur, SqlRetry is configured to only try twice, so we fail here
+      sql_retry.with_retries do |retriable_connection|
+        @helper.insert_records_at_ids(retriable_connection, [@locked_record_id])
+      end
+    end
+
+    exception = assert_raises { @helper.trigger_wait_lock }
+
+    assert_equal "Lock wait timeout exceeded; try restarting transaction", exception.message
+    assert_equal Mysql2::Error::TimeoutError, exception.class
+
+    assert_equal 2, @helper.record_count # no records inserted
+    puts "*" * 64
+  end
+end

data/spec/integration/sql_retry/lock_wait_timeout_test_helper.rb

@@ -0,0 +1,101 @@
+require 'yaml'
+class LockWaitTimeoutTestHelper
+  def initialize(lock_duration:, innodb_lock_wait_timeout:)
+    # This connection will be used exclusively to setup the test,
+    # assert pre-conditions and assert post-conditions.
+    # We choose to use a `Mysql2::Client` connection instead of
+    # `ActiveRecord::Base.establish_connection` because of AR's connection
+    # pool which forces thread syncronization. In this test,
+    # we want to intentionally create a lock to test retries,
+    # so that is an anti-feature.
+    @main_conn = new_mysql_connection
+
+    @lock_duration = lock_duration
+
+    # While implementing this, I discovered that MySQL seems to have an off-by-one
+    # bug with the innodb_lock_wait_timeout. If you ask it to wait 2 seconds, it will wait 3.
+    # In order to avoid surprisingly the user, let's account for that here, but also
+    # guard against a case where we go below 1, the minimum value.
+    raise ArgumentError, "innodb_lock_wait_timeout must be greater than or equal to 2" unless innodb_lock_wait_timeout >= 2
+    raise ArgumentError, "innodb_lock_wait_timeout must be an integer" if innodb_lock_wait_timeout.class != Integer
+    @innodb_lock_wait_timeout = innodb_lock_wait_timeout - 1
+
+    @threads = []
+    @queue = Queue.new
+  end
+
+  def create_table_to_lock(connection = main_conn)
+    connection.query("DROP TABLE IF EXISTS #{test_table_name};")
+    connection.query("CREATE TABLE #{test_table_name} (id INT, PRIMARY KEY (id)) ENGINE=InnoDB;")
+  end
+
+  def hold_lock(seconds = lock_duration, queue = @queue)
+    # We are intentionally choosing to create a gap in the between the IDs to
+    # create a gap lock.
+    insert_records_at_ids(main_conn, [1001,1003])
+    locked_id = 1002
+
+    # This is the locking thread. It creates gap lock. It must be created first.
+    @threads << Thread.new do
+      conn = new_mysql_connection
+      conn.query("START TRANSACTION;")
+      conn.query("DELETE FROM #{test_table_name} WHERE id=#{locked_id}") # we now have the lock
+      queue.push(true) # this will signal the waiting thread to unblock, now that the lock is held
+      sleep seconds # hold the lock, while the waiting thread is waiting/retrying
+      conn.query("ROLLBACK;") # release the lock
+    end
+
+    return locked_id
+  end
+
+  def record_count(connection = main_conn)
+    response = connection.query("SELECT COUNT(id) FROM #{test_table_name}")
+    response.first.values.first
+  end
+
+  def with_waiting_lock(lock_time = @lock_duration, queue = @queue)
+    @threads << Thread.new do
+      conn = new_mysql_connection
+      conn.query("SET SESSION innodb_lock_wait_timeout = #{innodb_lock_wait_timeout}") # set timeout to be less than lock_time, so the timeout will happen
+      queue.pop # this will block until the lock thread establishes lock
+      yield(conn) # invoke the code that should retry while lock is held
+    end
+  end
+
+  def trigger_wait_lock
+    @threads.each(&:join)
+  end
+
+  def insert_records_at_ids(connection, ids)
+    ids.each do |id|
+      connection.query "INSERT INTO #{test_table_name} (id) VALUES (#{id})"
+    end
+  end
+
+  private
+
+  attr_reader :main_conn, :lock_duration, :innodb_lock_wait_timeout
+
+  def new_mysql_connection
+    Mysql2::Client.new(
+      host: '127.0.0.1',
+      database: test_db_name,
+      username: db_config['master']['user'],
+      password: db_config['master']['password'],
+      port: db_config['master']['port'],
+      socket: db_config['master']['socket']
+    )
+  end
+
+  def test_db_name
+    @test_db_name ||= "test"
+  end
+
+  def db_config
+    @db_config ||= YAML.load_file(File.expand_path(File.dirname(__FILE__)) + '/../database.yml')
+  end
+
+  def test_table_name
+    @test_table_name ||= "lock_wait"
+  end
+end

data/spec/integration/table_spec.rb

@@ -0,0 +1,91 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+require File.expand_path(File.dirname(__FILE__)) + '/integration_helper'
+require 'lhm/table'
+
+describe Lhm::Table do
+  include IntegrationHelper
+
+  describe 'id numeric column requirement' do
+    describe 'when met' do
+      before(:each) do
+        connect_master!
+        @table = table_create(:custom_primary_key)
+      end
+
+      it 'should parse primary key' do
+        @table.pk.must_equal('pk')
+      end
+
+      it 'should parse indices' do
+        @table.
+          indices['index_custom_primary_key_on_id'].
+          must_equal(['id'])
+      end
+
+      it 'should parse columns' do
+        @table.
+          columns['id'][:type].
+          must_match(/(bigint|int)\(\d+\)/)
+      end
+
+      it 'should return true for method that should be renamed' do
+        @table.satisfies_id_column_requirement?.must_equal true
+      end
+
+      it 'should support bigint tables' do
+        @table = table_create(:bigint_table)
+        @table.satisfies_id_column_requirement?.must_equal true
+      end
+    end
+
+    describe 'when not met' do
+      before(:each) do
+        connect_master!
+      end
+
+      it 'should return false for a non-int id column' do
+        @table = table_create(:wo_id_int_column)
+        @table.satisfies_id_column_requirement?.must_equal false
+      end
+    end
+  end
+
+  describe Lhm::Table::Parser do
+    describe 'create table parsing' do
+      before(:each) do
+        connect_master!
+        @table = table_create(:users)
+      end
+
+      it 'should parse table name in show create table' do
+        @table.name.must_equal('users')
+      end
+
+      it 'should parse primary key' do
+        @table.pk.must_equal('id')
+      end
+
+      it 'should parse column type in show create table' do
+        @table.columns['username'][:type].must_equal('varchar(255)')
+      end
+
+      it 'should parse column metadata' do
+        assert_nil @table.columns['username'][:column_default]
+      end
+
+      it 'should parse indices' do
+        @table.
+          indices['index_users_on_username_and_created_at'].
+          must_equal(['username', 'created_at'])
+      end
+
+      it 'should parse index' do
+        @table.
+          indices['index_users_on_reference'].
+          must_equal(['reference'])
+      end
+    end
+  end
+end

data/spec/test_helper.rb

@@ -0,0 +1,32 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+if ENV['COV']
+  require 'simplecov'
+  SimpleCov.start
+end
+
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'minitest/mock'
+require 'mocha/minitest'
+require 'pathname'
+require 'lhm'
+
+$project = Pathname.new(File.dirname(__FILE__) + '/..').cleanpath
+$spec = $project.join('spec')
+$fixtures = $spec.join('fixtures')
+
+require 'active_record'
+require 'mysql2'
+
+logger = Logger.new STDOUT
+logger.level = Logger::WARN
+Lhm.logger = logger
+
+def without_verbose(&block)
+  old_verbose, $VERBOSE = $VERBOSE, nil
+  yield
+ensure
+  $VERBOSE = old_verbose
+end

data/spec/unit/atomic_switcher_spec.rb

@@ -0,0 +1,31 @@
+# Copyright (c) 2011 - 2013, SoundCloud Ltd., Rany Keddo, Tobias Bielohlawek, Tobias
+# Schmidt
+
+require File.expand_path(File.dirname(__FILE__)) + '/unit_helper'
+
+require 'lhm/table'
+require 'lhm/migration'
+require 'lhm/atomic_switcher'
+
+describe Lhm::AtomicSwitcher do
+  include UnitHelper
+
+  before(:each) do
+    @start       = Time.now
+    @origin      = Lhm::Table.new('origin')
+    @destination = Lhm::Table.new('destination')
+    @migration   = Lhm::Migration.new(@origin, @destination, @start)
+    @switcher    = Lhm::AtomicSwitcher.new(@migration, nil)
+  end
+
+  describe 'atomic switch' do
+    it 'should perform a single atomic rename' do
+      @switcher.
+        atomic_switch.
+        must_equal(
+          "rename table `origin` to `#{ @migration.archive_name }`, " \
+          '`destination` to `origin`'
+        )
+    end
+  end
+end