activejob-locking 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7cd905211ccba06fbbf2fac424009b84ab5fe769
-  data.tar.gz: c7c970994a0e5f3ad816c7b5da8ca28722d4596b
+  metadata.gz: e574b3a41612fff773ca03309e55b6a2a4bb2db0
+  data.tar.gz: 3ef9de73fa5ac528c317fd8218be929ce3e975f8
 SHA512:
-  metadata.gz: 1f5f4247c8f15cd41dc0692f1a638a775229404620cee8a6318e4c410dca20e922762145fe5af991c24d71cfacc045ec9dd53f266b4bfa6d9cf22bbd4eed0e6b
-  data.tar.gz: 7f9a485dac7c34835b7209ed3c7e2736d02ef735a8f6fc6575f8bdb9dcd2831289abe19a9d7c0823960b24a1b6eb6f74b231ac9c7408501abd9437b24d7bc912
+  metadata.gz: 28f284c0b260bfdc69387d901f5fb217d1afb512127b05a4a34a8399e0cf36718c33f0c60e857686572f0c4d340a9c83c8889ef3a50510a06114fe961e27b7df
+  data.tar.gz: 65c953f75b1795f7be08cd0d262b01584a6f850feb16ac4a7f2432fcedbd964e07820d7ebaa11e3a6c4a043cefbb2bdef315a2529b90069975b0778f13c23ab1

data/HISTORY.md

@@ -1,16 +1,21 @@
-## 0.3.0 (2017-06-21)
-
-- Cleanup handling of hosts
-
-## 0.3.0 (2017-06-21)
-
-- Change lock_key signature to match perform signature
-
-## 0.2.0 (2017-06-20)
-
-- Bug fixes
-- Improved tests
-
-## 0.1.0 (2017-01-16)
-
-- Initial release
+## 0.5.0 (2017-10-03)
+
+- Add enqueue_time parameter
+- Fix bug in setting enqueue time
+
+## 0.4.0 (2017-06-21)
+
+- Cleanup handling of hosts
+
+## 0.3.0 (2017-06-21)
+
+- Change lock_key signature to match perform signature
+
+## 0.2.0 (2017-06-20)
+
+- Bug fixes
+- Improved tests
+
+## 0.1.0 (2017-01-16)
+
+- Initial release

data/README.md

@@ -1,247 +1,274 @@
-ActiveJob Locking
-===================
-
-[![Build Status](https://secure.travis-ci.org/lantins/activejob-locking.png?branch=master)](http://travis-ci.org/cfis/activejob-locking)
-[![Gem Version](https://badge.fury.io/rb/activejob-locking.png)](http://badge.fury.io/rb/activejob-locking)
-
-activejob-locking lets you control how ActiveJobs are enqueued and performed:
-
-* Allow only one job to be enqueued at a time - thus a "unique" job
-* Allow only one job to be performed at a time - thus a "serialized" job
-
-There are many other similar gems including [resque-lock-timeout](https://github.com/lantins/resque-lock-timeout),
-[activejob-traffic-control](https://github.com/nickelser/activejob-traffic_control), [activejob-lock](https://github.com/idolweb/activejob-lock),
-[activejob-locks](https://github.com/erickrause/activejob-locks).  What is different about this gem is that it
-is agnostic on the locking mechanism.  In the same way that ActiveJob works with many apapters, ActiveJob Locking 
-works with a variety of locking gems.
- 
-Installation
-------------
-
-Add this line to your application's Gemfile:
-
-```ruby
-gem 'activejob-locking'
-```
-
-Unique Jobs
-------------
-Sometime you only want to enqueue one instance of a job.  No other similar job should be enqueued until the first one 
-is completed. 
-
-```ruby
-class UniqueJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  # Make sure the lock_key is always the same
-  def lock_key(object)
-    self.class.name
-  end
- 
-  def perform(object)
-    # do some work
-  end
-end
-```
-Only one instance of this job will ever be enqueued.  If an additional job is enqueued, it will either be dropped and
-never be enqueued or it will wait to the first job is performed.  That is controlled by the job
-[options](##options) described below.
-
-
-Serialized Jobs
-------------
-Sometime you only want to perform one instance of a job at a time.  No other similar job should be performed until the first one 
-is completed. 
-
-```ruby
-class SerializedJob < ActiveJob::Base
-  include ActiveJob::Locking::Serialized
-
-  # Make sure the lock_key is always the same
-  def lock_key
-    self.class.name
-  end
-
-  def perform
-    # do some work
-  end
-end
-```
-Only one instance of this job will ever be performed.  If an additional job is enqueued, it will wait in its que until
-to the first job is performed. 
-
-Locking
-------------
-Locks are used to control how jobs are enqueued and performed. The idea is that locks are stored in a distributed
-system such as [Redis](https://redis.io/) or [Memcached](https://memcached.org/) so they can be used by
-multiple servers to coordinate the enqueueing and performing of jobs.
-
-The ActiveJob Locking gem does not include a locking implementation. Instead it provides adapters for
-distributed locking gems. 
-
-Currently three gems are supported:
-
-* [redis-semaphore](https://github.com/dv/redis-semaphore) 
-
-* [suo](https://github.com/nickelser/suo)
-
-* [redlock-rb](https://github.com/leandromoreira/redlock-rb)
-
-If you would like to have an additional locking mechanism supported, please feel free to send in a pull request.
-
-Please see the [options](##options) section below on how to specify a locking adapter.
-
-
-Lock Key
----------
-
-Notice that the code samples above include a `lock_key` method. The return value of this method is used by the
-gem to create locks behind the scenes.  Thus it holds the key (pun intended) to controlling how jobs are enqueued
-and performed.
-
-By default the key is defined as:
-
-```ruby
- def lock_key(*args)
-   [self.class.name, serialize_arguments(self.arguments)].join('/')
- end 
-```
-Thus it has the format `<job class name>/<serialized_job_arguments>`
-
-The args passed to the lock key method are the same that are passed to the job's perform method.
-
-To use this gem, you will want to override this method per job.
-  
-### Examples
-
-Allow only one job per queue to be enqueued or performed: 
-  
-```ruby
- def lock_key(*args)
-   self.queue
- end 
-```
-
-Allow only one instance of a job class to be enqueued of performed:  
-  
-```ruby
- def lock_key(*args)
-   self.class.name
- end 
-```
-
-Options
--------
-The locking behavior can be dramatically changed by tweaking various options. There is a global set of options
-available at:
-
-```ruby
-ActiveJob::Locking.options
-```
-This should be updated using a Rails initializer.  Each job class can override individual options as it sees fit.
-
-### Adapter
-
-Use the adapter option to specify which locking gem to use.  
-
-Globally update:
-
-```ruby
-ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::SuoRedis
-```
-Locally update:
-
-```ruby
-class ExampleJob < ActiveJob::Base
-  include ActiveJob::Locking::Serialized
-
-  self.adapter = ActiveJob::Locking::Adapters::SuoRedis
-end
-```
-
-### Hosts
-
-An array of hosts for the distributed system. This format is dependent on the locking gem, but generally is a url or an existing Memcache or Redis
-connection. Please refer to the appropriate locking gem's documentation documentation.  
-
-Globally update:
-
-```ruby
-ActiveJob::Locking.options.hosts = ['localhost']
-```
-Locally update:
-
-```ruby
-class ExampleJob < ActiveJob::Base
-  include ActiveJob::Locking::Serialized
-
-  self.hosts = ['localhost']
-end
-```
-
-### lock_acquire_time
-
-The is the timeout for acquiring a lock.  The value is specified in seconds and defaults to 1. It must
-be greater than zero and cannot be nil.
-
-Globally update:
-
-```ruby
-ActiveJob::Locking.options.lock_acquire_time = 1
-```
-Locally update:
-
-```ruby
-class ExampleJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.lock_acquire_time = 1
-end
-```
-This greatly influences how enqueuing behavior works.  If the timeout is short, then jobs that are waiting to
-be enqueued are dropped and the before_enqueue callback will fail. If the timeout is infinite, then jobs will wait 
-in turn to get enqueued.  If the timeout is somewhere in between then it will depend on how long the jobs
-take to execute.
-
-### lock_time
-
-The is the time to live for any acquired locks.  For most locking gems this is mapped to their concept of "stale" locks.
-That means that if an attempt is made to access the lock after it is expired, it will be considered unlocked.  That is in
-contrast to aggressively removing locks for running jobs even if no other job has requested them.
-
-The value is specified in seconds and defaults to 100.
-
-Globally update:
-
-```ruby
-ActiveJob::Locking.options.lock_time = 100
-```
-Locally update:
-
-```ruby
-class ExampleJob < ActiveJob::Base
-  include ActiveJob::Locking::Serialized
-
-  self.lock_time = 100
-end
-```
-
-### AdapterOptions
-
-This is a hash table of options that should be sent to the lock gem when it is instantiated. Read the lock 
-gems documentation to find appropriate values.
-
-Globally update:
-
-```ruby
-ActiveJob::Locking.options.adapter_options = {}
-```
-Locally update (notice the different method name to avoid potential conflicts):
-
-```ruby
-class ExampleJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.adapter_options = {}
-end
-```
+ActiveJob Locking
+===================
+
+[![Build Status](https://secure.travis-ci.org/lantins/activejob-locking.png?branch=master)](http://travis-ci.org/cfis/activejob-locking)
+[![Gem Version](https://badge.fury.io/rb/activejob-locking.png)](http://badge.fury.io/rb/activejob-locking)
+
+activejob-locking lets you control how ActiveJobs are enqueued and performed:
+
+* Allow only one job to be enqueued at a time - thus a "unique" job
+* Allow only one job to be performed at a time - thus a "serialized" job
+
+There are many other similar gems including [resque-lock-timeout](https://github.com/lantins/resque-lock-timeout),
+[activejob-traffic-control](https://github.com/nickelser/activejob-traffic_control), [activejob-lock](https://github.com/idolweb/activejob-lock),
+[activejob-locks](https://github.com/erickrause/activejob-locks).  What is different about this gem is that it
+is agnostic on the locking mechanism.  In the same way that ActiveJob works with many apapters, ActiveJob Locking 
+works with a variety of locking gems.
+ 
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'activejob-locking'
+```
+
+Unique Jobs
+------------
+Sometime you only want to enqueue one instance of a job.  No other similar job should be enqueued until the first one 
+is completed. 
+
+```ruby
+class UniqueJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  # Make sure the lock_key is always the same
+  def lock_key(object)
+    self.class.name
+  end
+ 
+  def perform(object)
+    # do some work
+  end
+end
+```
+Only one instance of this job will ever be enqueued.  If an additional job is enqueued, it will either be dropped and
+never be enqueued or it will wait to the first job is performed.  That is controlled by the job
+[options](##options) described below.
+
+
+Serialized Jobs
+------------
+Sometime you only want to perform one instance of a job at a time.  No other similar job should be performed until the first one 
+is completed. 
+
+```ruby
+class SerializedJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  # Make sure the lock_key is always the same
+  def lock_key
+    self.class.name
+  end
+
+  def perform
+    # do some work
+  end
+end
+```
+Only one instance of this job will ever be performed.  If an additional job is enqueued, it will wait in its que until
+to the first job is performed. 
+
+Locking
+------------
+Locks are used to control how jobs are enqueued and performed. The idea is that locks are stored in a distributed
+system such as [Redis](https://redis.io/) or [Memcached](https://memcached.org/) so they can be used by
+multiple servers to coordinate the enqueueing and performing of jobs.
+
+The ActiveJob Locking gem does not include a locking implementation. Instead it provides adapters for
+distributed locking gems. 
+
+Currently three gems are supported:
+
+* [redis-semaphore](https://github.com/dv/redis-semaphore) 
+
+* [suo](https://github.com/nickelser/suo)
+
+* [redlock-rb](https://github.com/leandromoreira/redlock-rb)
+
+If you would like to have an additional locking mechanism supported, please feel free to send in a pull request.
+
+Please see the [options](##options) section below on how to specify a locking adapter.
+
+
+Lock Key
+---------
+
+Notice that the code samples above include a `lock_key` method. The return value of this method is used by the
+gem to create locks behind the scenes.  Thus it holds the key (pun intended) to controlling how jobs are enqueued
+and performed.
+
+By default the key is defined as:
+
+```ruby
+ def lock_key(*args)
+   [self.class.name, serialize_arguments(self.arguments)].join('/')
+ end 
+```
+Thus it has the format `<job class name>/<serialized_job_arguments>`
+
+The args passed to the lock key method are the same that are passed to the job's perform method.
+
+To use this gem, you will want to override this method per job.
+  
+### Examples
+
+Allow only one job per queue to be enqueued or performed: 
+  
+```ruby
+ def lock_key(*args)
+   self.queue
+ end 
+```
+
+Allow only one instance of a job class to be enqueued of performed:  
+  
+```ruby
+ def lock_key(*args)
+   self.class.name
+ end 
+```
+
+Options
+-------
+The locking behavior can be dramatically changed by tweaking various options. There is a global set of options
+available at:
+
+```ruby
+ActiveJob::Locking.options
+```
+This should be updated using a Rails initializer.  Each job class can override individual options as it sees fit.
+
+### Adapter
+
+Use the adapter option to specify which locking gem to use.  
+
+Globally update:
+
+```ruby
+ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::SuoRedis
+```
+Locally update:
+
+```ruby
+class ExampleJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  self.adapter = ActiveJob::Locking::Adapters::SuoRedis
+end
+```
+
+### Hosts
+
+An array of hosts for the distributed system. This format is dependent on the locking gem, but generally is a url or an existing Memcache or Redis
+connection. Please refer to the appropriate locking gem's documentation documentation.  
+
+Globally update:
+
+```ruby
+ActiveJob::Locking.options.hosts = ['localhost']
+```
+Locally update:
+
+```ruby
+class ExampleJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  self.hosts = ['localhost']
+end
+```
+
+### lock_time
+
+The is the time to live for any acquired locks.  For most locking gems this is mapped to their concept of "stale" locks.
+That means that if an attempt is made to access the lock after it is expired, it will be considered unlocked.  That is in
+contrast to aggressively removing locks for running jobs even if no other job has requested them.
+
+The value is specified in seconds and defaults to 100.
+
+Globally update:
+
+```ruby
+ActiveJob::Locking.options.lock_time = 100
+```
+Locally update:
+
+```ruby
+class ExampleJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  self.lock_time = 100
+end
+```
+
+You almost surely want the lock_time to be greater than the time it takes to execute the job.  Otherwise, the lock will expire
+and extra jobs will start to run. When the job finishes, or fails, the lock will be released.  However, remember that the job 
+could be terminated by the operating system or a monitoring system (such as monit). In that case, the lock won't be released
+and will remain in force until its lock_time expires. 
+
+### lock_acquire_time
+
+The is the timeout for acquiring a lock.  The value is specified in seconds and defaults to 1. It must
+be greater than zero and cannot be nil.
+
+Globally update:
+
+```ruby
+ActiveJob::Locking.options.lock_acquire_time = 1
+```
+Locally update:
+
+```ruby
+class ExampleJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.lock_acquire_time = 1
+end
+```
+
+Remember that most locking gems block the current thread when trying to acquire a lock. Therefore you likely want
+lock_acquire_time to be low.  However, the lower it is the more likely that unique jobs that are enqueued will 
+expire and be dropped.
+
+### enqueue_time
+
+The is the time to re-enqueue a job if the lock_time has expired. Thus this value is only relevant for
+serialized jobs since unique jobs will be dropped instead of enqueded.
+
+The value is specified in seconds and defaults to 100.
+
+Globally update:
+
+```ruby
+ActiveJob::Locking.options.enqueue_time = 100
+```
+Locally update:
+
+```ruby
+class ExampleJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  self.enqueue_time = 100
+end
+```
+
+### AdapterOptions
+
+This is a hash table of options that should be sent to the lock gem when it is instantiated. Read the lock 
+gems documentation to find appropriate values.
+
+Globally update:
+
+```ruby
+ActiveJob::Locking.options.adapter_options = {}
+```
+Locally update (notice the different method name to avoid potential conflicts):
+
+```ruby
+class ExampleJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.adapter_options = {}
+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)
+          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

@@ -7,8 +7,8 @@ module ActiveJob
         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
+        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

data/lib/activejob/locking/options.rb

@@ -7,16 +7,31 @@ module ActiveJob
       attr_accessor :hosts
       attr_accessor :lock_time
       attr_accessor :lock_acquire_time
+      attr_accessor :enqueue_time
       attr_accessor :adapter_options
 
       def initialize(options = {})
         @adapter = options[:adapter]
         @hosts = options[:hosts]
+        @enqueue_time = options[:enqueue_time]
         @lock_time = options[:lock_time]
         @lock_acquire_time = options[:lock_acquire_time]
         @adapter_options = options[:adapter_options]
       end
 
+      def enqueue_time=(value)
+        case value
+          when NilClass
+            raise(ArgumentError, 'Enqueue time must be set')
+          when ActiveSupport::Duration
+            @enqueue_time = value.value
+          when 0
+            raise(ArgumentError, 'Enqueue time must be greater than zero')
+          else
+            @enqueue_time = value
+        end
+      end
+
       def lock_time=(value)
         case value
           when NilClass
@@ -47,6 +62,7 @@ module ActiveJob
         result = self.dup
         result.adapter = other.adapter if other.adapter
         result.hosts = other.hosts if other.hosts
+        result.enqueue_time = other.enqueue_time if other.enqueue_time
         result.lock_time = other.lock_time if other.lock_time
         result.lock_acquire_time = other.lock_acquire_time if other.lock_acquire_time
         result.adapter_options = other.adapter_options if other.adapter_options

data/lib/activejob/locking/serialized.rb

@@ -14,7 +14,7 @@ module ActiveJob
               job.adapter.unlock
             end
           else
-            job.class.set(wait: job.class.lock_acquire_time).perform_later(*job.arguments)
+            job.class.set(wait: job.adapter.options.enqueue_time).perform_later(*job.arguments)
           end
         end
       end

data/test/jobs/fail_job.rb

@@ -1,15 +1,15 @@
-class FailJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    raise(ArgumentError, 'Job failed')
-  end
+class FailJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    raise(ArgumentError, 'Job failed')
+  end
 end

data/test/jobs/serial_job.rb

@@ -1,15 +1,15 @@
-class SerialJob < ActiveJob::Base
-  include ActiveJob::Locking::Serialized
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    sleep(sleep_time)
-  end
+class SerialJob < ActiveJob::Base
+  include ActiveJob::Locking::Serialized
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    sleep(sleep_time)
+  end
 end

data/test/jobs/unique_job.rb

@@ -1,15 +1,15 @@
-class UniqueJob < ActiveJob::Base
-  include ActiveJob::Locking::Unique
-
-  self.lock_acquire_time = 2
-
-  # We want the job ids to be all the same for testing
-  def lock_key(index, sleep_time)
-    self.class.name
-  end
-
-  # Pass in index so we can distinguish different jobs
-  def perform(index, sleep_time)
-    sleep(sleep_time)
-  end
+class UniqueJob < ActiveJob::Base
+  include ActiveJob::Locking::Unique
+
+  self.lock_acquire_time = 2
+
+  # We want the job ids to be all the same for testing
+  def lock_key(index, sleep_time)
+    self.class.name
+  end
+
+  # Pass in index so we can distinguish different jobs
+  def perform(index, sleep_time)
+    sleep(sleep_time)
+  end
 end

data/test/test_suite.rb

@@ -1,12 +1,12 @@
-%w(
-  test_serialized_memory
-  test_serialized_redis_semaphore
-  test_serialized_redlock
-  test_serialized_suo_redis
-  test_unique_memory
-  test_unique_redis_semaphore
-  test_unique_redlock
-  test_unique_suo_redis
-).each do |test|
-  require File.expand_path("../#{test}", __FILE__)
-end
+%w(
+  test_serialized_memory
+  test_serialized_redis_semaphore
+  test_serialized_redlock
+  test_serialized_suo_redis
+  test_unique_memory
+  test_unique_redis_semaphore
+  test_unique_redlock
+  test_unique_suo_redis
+).each do |test|
+  require File.expand_path("../#{test}", __FILE__)
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activejob-locking
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Charlie Savage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-06-23 00:00:00.000000000 Z
+date: 2017-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
@@ -154,7 +154,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.11
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: ActiveJob locking to control how jobs are enqueued and performed.