activejob-locking 0.4.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7cd905211ccba06fbbf2fac424009b84ab5fe769
-  data.tar.gz: c7c970994a0e5f3ad816c7b5da8ca28722d4596b
+SHA256:
+  metadata.gz: a3908dd5b2d14cfcb98ba3c6fc4b290e63cf63ecf9e1d202dc57a881b2cde088
+  data.tar.gz: 904d86bca070382eac808c378fe9915f5eb5c3156ba5eff903599d6c6f229989
 SHA512:
-  metadata.gz: 1f5f4247c8f15cd41dc0692f1a638a775229404620cee8a6318e4c410dca20e922762145fe5af991c24d71cfacc045ec9dd53f266b4bfa6d9cf22bbd4eed0e6b
-  data.tar.gz: 7f9a485dac7c34835b7209ed3c7e2736d02ef735a8f6fc6575f8bdb9dcd2831289abe19a9d7c0823960b24a1b6eb6f74b231ac9c7408501abd9437b24d7bc912
+  metadata.gz: deb838dd268dd4cf13584de0ff7ee59979c400e1c0f0ffabf9852ba29fa23765f00a89871fbb4ce6daf16dc0a5d65297579da990a0c040470bcc86317aa5a835
+  data.tar.gz: 0e0d4f83c513aa887aede2907e304b3a6e95207ed7743882cfd0c149adc60acd93574431aef4f8a9d2c16504d1692215360e69bcb73fb6c467bc701bbca03bf9

data/Gemfile

@@ -1,10 +1,10 @@
-source 'https://rubygems.org'
-
-gem 'activejob', :require => 'active_job'
-
-group :test do
-  gem 'minitest'
-  gem 'redis-semaphore'
-  gem 'redlock'
-  gem 'suo'
-end
+source 'https://rubygems.org'
+
+gem 'activejob', :require => 'active_job'
+
+group :test do
+  gem 'minitest'
+  gem 'redis-semaphore'
+  gem 'redlock'
+  gem 'suo'
+end

data/HISTORY.md

@@ -1,16 +1,37 @@
-## 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.6.2 (2020-07-12)
+
+Fix unlock for Redlock adapter by correct deserializing keys as symbols (Volodymyr Byno)
+
+## 0.6.1 (2020-04-01)
+
+- Support Rails exception discarding when deserializing (Mattias Pfeiffer)
+
+## 0.6.0 (2019-05-19)
+
+- Update for Rails 6.x
+
+## 0.5.1 (2017-10-08)
+
+- Loosen activejob dependency to work with ActiveJob 5.x
+
+## 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/LICENSE

@@ -1,20 +1,20 @@
-Copyright (c) 2017 Charlie Savage
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-Software), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright (c) 2017 Charlie Savage
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+Software), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

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
+```