activejob-locking 0.4.0 → 0.6.2

data/Rakefile

@@ -1,21 +1,21 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rubygems/package_task'
-
-# Set global variable so other tasks can access them
-::PROJECT_ROOT = File.expand_path(".")
-::GEM_NAME = 'activejob-locking'
-
-# Read the spec file
-spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
-
-# Setup Rake tasks for managing the gem
-Gem::PackageTask.new(spec).define
-
-desc 'Run unit tests.'
-Rake::TestTask.new(:test) do |task|
-  task.test_files = FileList['test/test_*.rb']
-  task.verbose = true
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rubygems/package_task'
+
+# Set global variable so other tasks can access them
+::PROJECT_ROOT = File.expand_path(".")
+::GEM_NAME = 'activejob-locking'
+
+# Read the spec file
+spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
+
+# Setup Rake tasks for managing the gem
+Gem::PackageTask.new(spec).define
+
+desc 'Run unit tests.'
+Rake::TestTask.new(:test) do |task|
+  task.test_files = FileList['test/test_*.rb']
+  task.verbose = true
 end

data/lib/activejob-locking.rb

@@ -1,23 +1,24 @@
-require 'activejob/locking/adapters/base'
-require 'activejob/locking/adapters/memory'
-
-require 'activejob/locking/base'
-require 'activejob/locking/unique'
-require 'activejob/locking/serialized'
-
-require 'activejob/locking/options'
-
-module ActiveJob
-  module Locking
-    @options = ActiveJob::Locking::Options.new(adapter: ActiveJob::Locking::Adapters::Memory,
-                                               hosts: ['localhost'],
-                                               lock_time: 100,
-                                               lock_acquire_time: 1,
-                                               adapter_options: {})
-
-    def self.options
-      @options
-    end
-  end
-end
-
+require 'activejob/locking/adapters/base'
+require 'activejob/locking/adapters/memory'
+
+require 'activejob/locking/base'
+require 'activejob/locking/unique'
+require 'activejob/locking/serialized'
+
+require 'activejob/locking/options'
+
+module ActiveJob
+  module Locking
+    @options = ActiveJob::Locking::Options.new(adapter: ActiveJob::Locking::Adapters::Memory,
+                                               hosts: ['localhost'],
+                                               enqueue_time: 100, # seconds
+                                               lock_time: 100, # seconds
+                                               lock_acquire_time: 1, # seconds
+                                               adapter_options: {})
+
+    def self.options
+      @options
+    end
+  end
+end
+

data/lib/activejob/locking/adapters/base.rb

@@ -1,32 +1,32 @@
-module ActiveJob
-  module Locking
-    module Adapters
-      class Base
-        attr_reader :key, :options, :lock_manager
-        attr_accessor :lock_token
-
-        def initialize(key, options)
-          @key = key
-          @options = options
-          @lock_manager = self.create_lock_manager
-        end
-
-        def create_lock_manager
-          raise('Subclass must implement')
-        end
-
-        def lock
-          raise('Subclass must implement')
-        end
-
-        def unlock
-          raise('Subclass must implement')
-        end
-
-        def refresh_lock!(refresh)
-          raise('Subclass must implement')
-        end
-      end
-    end
-  end
+module ActiveJob
+  module Locking
+    module Adapters
+      class Base
+        attr_reader :key, :options, :lock_manager
+        attr_accessor :lock_token
+
+        def initialize(key, options)
+          @key = key
+          @options = options
+          @lock_manager = self.create_lock_manager
+        end
+
+        def create_lock_manager
+          raise('Subclass must implement')
+        end
+
+        def lock
+          raise('Subclass must implement')
+        end
+
+        def unlock
+          raise('Subclass must implement')
+        end
+
+        def refresh_lock!(refresh)
+          raise('Subclass must implement')
+        end
+      end
+    end
+  end
 end

data/lib/activejob/locking/adapters/memory.rb

@@ -1,58 +1,58 @@
-module ActiveJob
-  module Locking
-    module Adapters
-      class Memory < Base
-        @hash = Hash.new
-        @mutex = Mutex.new
-
-        def self.lock(key)
-          @mutex.synchronize do
-            if @hash[key]
-              false
-            else
-              @hash[key] = Time.now
-            end
-          end
-        end
-
-        def self.unlock(key)
-          @mutex.synchronize do
-            @hash.delete(key)
-          end
-        end
-
-        def self.locked?(key)
-          @mutex.synchronize do
-            @hash.include?(key)
-          end
-        end
-
-        def self.reset
-          @mutex.synchronize do
-            @hash = Hash.new
-          end
-        end
-
-        def create_lock_manager
-        end
-
-        def lock
-          finish = Time.now + self.options.lock_acquire_time
-          sleep_time = [5, self.options.lock_acquire_time / 5].min
-
-          begin
-            lock = self.class.lock(key)
-            return lock if lock
-            sleep(sleep_time)
-          end while Time.now < finish
-
-          false
-        end
-
-        def unlock
-          self.class.unlock(self.key)
-        end
-      end
-    end
-  end
+module ActiveJob
+  module Locking
+    module Adapters
+      class Memory < Base
+        @hash = Hash.new
+        @mutex = Mutex.new
+
+        def self.lock(key)
+          @mutex.synchronize do
+            if @hash[key]
+              false
+            else
+              @hash[key] = Time.now
+            end
+          end
+        end
+
+        def self.unlock(key)
+          @mutex.synchronize do
+            @hash.delete(key)
+          end
+        end
+
+        def self.locked?(key)
+          @mutex.synchronize do
+            @hash.include?(key)
+          end
+        end
+
+        def self.reset
+          @mutex.synchronize do
+            @hash = Hash.new
+          end
+        end
+
+        def create_lock_manager
+        end
+
+        def lock
+          finish = Time.now + self.options.lock_acquire_time
+          sleep_time = [5, self.options.lock_acquire_time / 5].min
+
+          begin
+            lock = self.class.lock(key)
+            return lock if lock
+            sleep(sleep_time)
+          end while Time.now < finish
+
+          false
+        end
+
+        def unlock
+          self.class.unlock(self.key)
+        end
+      end
+    end
+  end
 end

data/lib/activejob/locking/adapters/redis-semaphore.rb

@@ -1,26 +1,26 @@
-require 'redis-semaphore'
-
-module ActiveJob
-  module Locking
-    module Adapters
-      class RedisSemaphore < Base
-        def create_lock_manager
-          mapped_options = {host: self.options.hosts.first,
-                            resources: 1,
-                            stale_client_timeout: self.options.lock_time}.merge(self.options.adapter_options)
-
-          Redis::Semaphore.new(self.key, mapped_options)
-        end
-
-        def lock
-          self.lock_token = self.lock_manager.lock(self.options.lock_acquire_time)
-        end
-
-        def unlock
-          self.lock_manager.signal(self.lock_token)
-          self.lock_token = nil
-        end
-      end
-    end
-  end
-end
+require 'redis-semaphore'
+
+module ActiveJob
+  module Locking
+    module Adapters
+      class RedisSemaphore < Base
+        def create_lock_manager
+          mapped_options = {host: self.options.hosts.first,
+                            resources: 1,
+                            stale_client_timeout: self.options.lock_time}.merge(self.options.adapter_options)
+
+          Redis::Semaphore.new(self.key, mapped_options)
+        end
+
+        def lock
+          self.lock_token = self.lock_manager.lock(self.options.lock_acquire_time)
+        end
+
+        def unlock
+          self.lock_manager.signal(self.lock_token)
+          self.lock_token = nil
+        end
+      end
+    end
+  end
+end

data/lib/activejob/locking/adapters/redlock.rb

@@ -1,26 +1,26 @@
-require 'redlock'
-
-module ActiveJob
-  module Locking
-    module Adapters
-      class Redlock < Base
-        def create_lock_manager
-          mapped_options = self.options.adapter_options
-          mapped_options[:retry_count] = 2 # Try to get the lock and then try again when timeout is expiring--
-          mapped_options[:retry_delay] = self.options.lock_acquire_time * 1000 # convert from seconds to milliseconds
-
-          ::Redlock::Client.new(self.options.hosts, mapped_options)
-        end
-
-        def lock
-          self.lock_token = self.lock_manager.lock(self.key, self.options.lock_time * 1000)
-        end
-
-        def unlock
-          self.lock_manager.unlock(self.lock_token)
-          self.lock_token = nil
-        end
-      end
-    end
-  end
-end
+require 'redlock'
+
+module ActiveJob
+  module Locking
+    module Adapters
+      class Redlock < Base
+        def create_lock_manager
+          mapped_options = self.options.adapter_options
+          mapped_options[:retry_count] = 2 # Try to get the lock and then try again when timeout is expiring--
+          mapped_options[:retry_delay] = self.options.lock_acquire_time * 1000 # convert from seconds to milliseconds
+
+          ::Redlock::Client.new(self.options.hosts, mapped_options)
+        end
+
+        def lock
+          self.lock_token = self.lock_manager.lock(self.key, self.options.lock_time * 1000)
+        end
+
+        def unlock
+          self.lock_manager.unlock(self.lock_token.symbolize_keys)
+          self.lock_token = nil
+        end
+      end
+    end
+  end
+end

data/lib/activejob/locking/adapters/suo-redis.rb

@@ -1,25 +1,25 @@
-require 'suo'
-
-module ActiveJob
-  module Locking
-    module Adapters
-      class SuoRedis < Base
-        def create_lock_manager
-          mapped_options = {connection: {host: self.options.hosts.first},
-                            stale_lock_expiration: self.options.lock_time,
-                            acquisition_timeout: self.options.lock_acquire_time}
-
-          Suo::Client::Redis.new(self.key, mapped_options)
-        end
-
-        def lock
-          self.lock_token = self.lock_manager.lock
-        end
-
-        def unlock
-          self.lock_manager.unlock(self.lock_token)
-        end
-      end
-    end
-  end
-end
+require 'suo'
+
+module ActiveJob
+  module Locking
+    module Adapters
+      class SuoRedis < Base
+        def create_lock_manager
+          mapped_options = {connection: {host: self.options.hosts.first},
+                            stale_lock_expiration: self.options.lock_time,
+                            acquisition_timeout: self.options.lock_acquire_time}
+
+          Suo::Client::Redis.new(self.key, mapped_options)
+        end
+
+        def lock
+          self.lock_token = self.lock_manager.lock
+        end
+
+        def unlock
+          self.lock_manager.unlock(self.lock_token)
+        end
+      end
+    end
+  end
+end

data/lib/activejob/locking/base.rb

@@ -1,51 +1,55 @@
-module ActiveJob
-  module Locking
-    module Base
-      extend ::ActiveSupport::Concern
-
-      module ClassMethods
-        def lock_options
-          @lock_options ||= ActiveJob::Locking::Options.new
-        end
-        delegate :adapter, :hosts, :lock_time, :lock_acquire_time, :adapter_options, to: :lock_options
-        delegate :adapter=, :hosts=, :lock_time=, :lock_acquire_time=, :adapter_options=, to: :lock_options
-      end
-
-      included do
-        # We need to serialize the lock token that some gems create because it could be released in a different process
-        def serialize
-          result = super
-          result['lock_token'] = self.adapter.lock_token
-          result
-        end
-
-        def deserialize(job_data)
-          super
-          self.adapter.lock_token = job_data['lock_token']
-        end
-
-        def lock_key(*args)
-          [self.class.name, serialize_arguments(self.arguments)].join('/')
-        end
-
-        def adapter
-          @adapter ||= begin
-            # Make sure arguments are deserialized so calling lock key is safe
-            deserialize_arguments_if_needed
-
-            # Merge local and global options
-            merged_options = ActiveJob::Locking.options.dup.merge(self.class.lock_options)
-
-            # Get the key
-            base_key = self.lock_key(*self.arguments)
-            key = "activejoblocking:#{base_key}"
-
-            # Remember the lock might be acquired in one process and released in another
-            merged_options.adapter.new(key, merged_options)
-          end
-          @adapter
-        end
-      end
-    end
-  end
+module ActiveJob
+  module Locking
+    module Base
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def lock_options
+          @lock_options ||= ActiveJob::Locking::Options.new
+        end
+        delegate :adapter, :enqueue_time, :hosts, :lock_time, :lock_acquire_time, :adapter_options, to: :lock_options
+        delegate :adapter=, :enqueue_time=, :hosts=, :lock_time=, :lock_acquire_time=, :adapter_options=, to: :lock_options
+      end
+
+      included do
+        # We need to serialize the lock token that some gems create because it could be released in a different process
+        def serialize
+          result = super
+          result['lock_token'] = self.adapter.lock_token
+          result
+        end
+
+        def deserialize(job_data)
+          super
+          self.adapter.lock_token = job_data['lock_token']
+        end
+
+        def lock_key(*args)
+          [self.class.name, serialize_arguments(self.arguments)].join('/')
+        end
+
+        def adapter
+          @adapter ||= begin
+            # Make sure arguments are deserialized so calling lock key is safe
+            begin
+              deserialize_arguments_if_needed
+            rescue => exception
+              rescue_with_handler(exception) || raise
+            end
+
+            # Merge local and global options
+            merged_options = ActiveJob::Locking.options.dup.merge(self.class.lock_options)
+
+            # Get the key
+            base_key = self.lock_key(*self.arguments)
+            key = "activejoblocking:#{base_key}"
+
+            # Remember the lock might be acquired in one process and released in another
+            merged_options.adapter.new(key, merged_options)
+          end
+          @adapter
+        end
+      end
+    end
+  end
 end