mysql_framework 0.0.12 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d259c4f34ff15a7c344bdfd29788a81e09a9d02bb3eba445fb8826658bb20fe
-  data.tar.gz: 2cb83a4a3082c83605694b20d3c67e89f99b1e3f494b98d182759eefeab43888
+  metadata.gz: b3dccb6db17fc9881471f03e6450c885a168adae746b98b913847a2499df1fc1
+  data.tar.gz: 4fa04c68791c529d75ce4889695907c6fd5b60d06c800480550de2161608d532
 SHA512:
-  metadata.gz: 363b29a8cc5ac738d72ad5b6406f3e3bb7c2897364f7cdee4df72b4769af02a78ce31781baa1545060fc51d266c584dcfc02c155e614048c4e80eaa9986c34af
-  data.tar.gz: 962a2dd53afc91a9ab80cf1f6df071577e36b197f7b981a03962425ac7c444da2603fae5a492c5265630f8f8e90f627b79006211943a9d47a63a6a9d676ab338
+  metadata.gz: 60be2204e33c1044793119d9e8fa6340f5960df8a0430beb47672b6687465a435f13da528e2a60d6f6667871b89f3cd25136b1f0eddc1d991131b4626c867cd9
+  data.tar.gz: 32a4c64e9febc04f5135026e08095180acad6e9a2fd39f17d6fdca521f16978584ad3f3a3def0a0c0fc00da7a26660b6330d46350f8687f232670a13429d50b2

data/lib/mysql_framework/scripts/lock_manager.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'redlock'
+
+module MysqlFramework
+  module Scripts
+    class LockManager
+      def initialize
+        @pool = Queue.new
+      end
+
+      # This method is called to request a lock (Default 5 minutes)
+      def request_lock(key:, ttl: default_ttl, max_attempts: default_max_retries, retry_delay: default_retry_delay)
+        MysqlFramework.logger.info { "[#{self.class}] - Requesting lock: #{key}." }
+
+        lock = false
+        count = 0
+
+        loop do
+          # request a lock
+          lock = with_client { |client| client.lock(key, ttl) }
+
+          # if lock was received break out of the loop
+          break if lock
+
+          # lock was not received so increment request count
+          count += 1
+
+          MysqlFramework.logger.debug do
+            "[#{self.class}] - Key is currently locked, waiting for lock: #{key} | Wait count: #{count}."
+          end
+
+          # check if lock requests have exceeded max request attempts
+          raise "Resource is already locked. Lock key: #{key}. Max attempt exceeded." if count == max_attempts
+
+          # sleep and try requesting the lock again
+          sleep(retry_delay)
+        end
+
+        lock
+      end
+
+      # This method is called to release a lock
+      def release_lock(key:, lock:)
+        return if lock.nil?
+
+        MysqlFramework.logger.info { "[#{self.class}] - Releasing lock: #{key}." }
+
+        with_client { |client| client.unlock(lock) }
+      end
+
+      # This method is called to request and release a lock around yielding to a user supplied block
+      def with_lock(key:, ttl: default_ttl, max_attempts: default_max_retries, retry_delay: default_retry_delay)
+        raise 'Block must be specified.' unless block_given?
+
+        begin
+          lock = request_lock(key: key, ttl: ttl, max_attempts: max_attempts, retry_delay: retry_delay)
+          yield
+        ensure
+          release_lock(key: key, lock: lock)
+        end
+      end
+
+      # This method is called to retrieve a Redlock client from the pool
+      def fetch_client
+        @pool.pop(true)
+      rescue StandardError
+        # By not letting redlock retry we will rely on the retry that happens in this class
+        Redlock::Client.new([redis_url], retry_jitter: retry_jitter, retry_count: 1, retry_delay: 0)
+      end
+
+      # This method is called to retrieve a Redlock client from the pool and yield it to a block
+      def with_client
+        client = fetch_client
+        yield client
+      ensure
+        @pool.push(client)
+      end
+
+      private
+
+      def redis_url
+        ENV.fetch('REDIS_URL')
+      end
+
+      def default_ttl
+        @default_ttl ||= Integer(ENV.fetch('MYSQL_MIGRATION_LOCK_TTL', 2000))
+      end
+
+      def default_max_retries
+        @default_max_retries ||= Integer(ENV.fetch('MYSQL_MIGRATION_LOCK_MAX_ATTEMPTS', 300))
+      end
+
+      def default_retry_delay
+        @default_retry_delay ||= Float(ENV.fetch('MYSQL_MIGRATION_LOCK_RETRY_DELAY_S', 1.0))
+      end
+
+      def retry_jitter
+        @retry_jitter ||= Integer(ENV.fetch('MYSQL_MIGRATION_LOCK_JITTER_MS', 50))
+      end
+    end
+  end
+end

data/lib/mysql_framework/scripts/manager.rb

@@ -8,9 +8,7 @@ module MysqlFramework
       end
 
       def execute
-        lock_manager.lock(self.class, migration_ttl) do |locked|
-          raise unless locked
-
+        lock_manager.with_lock(key: self.class) do
           initialize_script_history
 
           executed_scripts = retrieve_executed_scripts
@@ -29,9 +27,7 @@ module MysqlFramework
       end
 
       def apply_by_tag(tags)
-        lock_manager.lock(self.class, migration_ttl) do |locked|
-          raise unless locked
-
+        lock_manager.with_lock(key: self.class) do
           initialize_script_history
 
           mysql_connector.transaction do |client|
@@ -113,11 +109,7 @@ module MysqlFramework
       attr_reader :mysql_connector
 
       def lock_manager
-        @lock_manager ||= Redlock::Client.new([ENV.fetch('REDIS_URL')])
-      end
-
-      def migration_ttl
-        @migration_ttl ||= Integer(ENV.fetch('MYSQL_MIGRATION_LOCK_TTL', 2000))
+        @lock_manager ||= MysqlFramework::Scripts::LockManager.new
       end
 
       def migration_table_name

data/lib/mysql_framework/scripts.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'scripts/base'
+require_relative 'scripts/lock_manager'
 require_relative 'scripts/manager'
 require_relative 'scripts/table'

data/lib/mysql_framework/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MysqlFramework
-  VERSION = '0.0.12'
+  VERSION = '0.1.1'
 end

data/lib/mysql_framework.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require 'mysql2'
-require 'redlock'
 
 require_relative 'mysql_framework/connector'
 require_relative 'mysql_framework/logger'

data/spec/lib/mysql_framework/scripts/lock_manager_spec.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+RSpec.describe MysqlFramework::Scripts::LockManager do
+  describe '#fetch_client' do
+    context 'when the connection pool is empty' do
+      it 'returns a new redlock client' do
+        expect(subject.fetch_client).to be_a(Redlock::Client)
+      end
+    end
+
+    context 'when the connection pool is NOT empty' do
+      let(:client) { Redlock::Client.new([ENV['REDIS_URL']]) }
+
+      before do
+        pool = subject.instance_variable_get(:@pool)
+        pool.push(client)
+      end
+
+      it 'returns a redlock client from the pool' do
+        expect(subject.fetch_client).to eq client
+      end
+    end
+  end
+
+  describe '#with_lock' do
+    let(:key) { SecureRandom.uuid }
+
+    context 'When key is NOT locked' do
+      context 'when a block is specified' do
+        let(:foo) { {} }
+
+        it 'requests a lock, executes the block and releases the lock' do
+          subject.with_lock(key: key, ttl: 1_000) do
+            foo[:bar] = 'abc'
+            sleep(0.1)
+          end
+
+          expect(foo[:bar]).to eq 'abc'
+          expect(subject.request_lock(key: key)).not_to be_nil
+        end
+      end
+    end
+  end
+
+  describe '#request_lock' do
+    let(:key) { SecureRandom.uuid }
+
+    context 'When key is NOT locked' do
+      it 'returns a lock' do
+        expect(subject.request_lock(key: key)).not_to be_nil
+      end
+    end
+
+    context 'When key is locked' do
+      before { subject.request_lock(key: key, ttl: 3_000) }
+
+      context 'but the lock expires within the wait ttl' do
+        it 'returns a lock' do
+          expect(subject.request_lock(key: key, max_attempts: 5, retry_delay: 1)).not_to be_nil
+        end
+      end
+
+      it 'raises a KeyLockError' do
+        expect { subject.request_lock(key: key, max_attempts: 1, retry_delay: 1) }.to raise_error(RuntimeError)
+      end
+    end
+  end
+
+  describe '#release_lock' do
+    let(:key) { SecureRandom.uuid }
+    let(:lock) { subject.request_lock(key: key) }
+
+    it 'releases the lock' do
+      expect { subject.release_lock(key: key, lock: lock) }.not_to raise_error
+      expect(subject.request_lock(key: key, max_attempts: 1, retry_delay: 1)).not_to be_nil
+    end
+
+    context 'when lock is nil' do
+      it 'does not error' do
+        expect { subject.release_lock(key: key, lock: nil) }.not_to raise_error
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mysql_framework
 version: !ruby/object:Gem::Version
-  version: 0.0.12
+  version: 0.1.1
 platform: ruby
 authors:
 - Sage
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-11-27 00:00:00.000000000 Z
+date: 2018-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -108,6 +108,7 @@ files:
 - lib/mysql_framework/logger.rb
 - lib/mysql_framework/scripts.rb
 - lib/mysql_framework/scripts/base.rb
+- lib/mysql_framework/scripts/lock_manager.rb
 - lib/mysql_framework/scripts/manager.rb
 - lib/mysql_framework/scripts/table.rb
 - lib/mysql_framework/sql_column.rb
@@ -118,6 +119,7 @@ files:
 - spec/lib/mysql_framework/connector_spec.rb
 - spec/lib/mysql_framework/logger_spec.rb
 - spec/lib/mysql_framework/scripts/base_spec.rb
+- spec/lib/mysql_framework/scripts/lock_manager_spec.rb
 - spec/lib/mysql_framework/scripts/manager_spec.rb
 - spec/lib/mysql_framework/sql_column_spec.rb
 - spec/lib/mysql_framework/sql_condition_spec.rb