active_job_lock 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d693fcdbfbfa1a7b23caad27365204b54ae568a8
+  data.tar.gz: 85ac93a9e83d532daffba6d80ac63c55115b9539
+SHA512:
+  metadata.gz: 0d916369eea001d36f7d4401208a75195eed7979b5d7137ede68e1ca32a17bb5fc0ccb02457e9334fbbb9f6dd9e265917e2ecaca3615c1120618dc199995b132
+  data.tar.gz: 2b3b56f70bcd04dcf62632e11ae9734ac4553b6b487791696e10e81237a8cbe3169b179f68d530f09a44be39f0cdc992b863c39300edec0cefe851bae79e3ca8

data/HISTORY.md

@@ -0,0 +1,3 @@
+## 0.1.0 (2016-07-27)
+
+- Initial release of `active_job_lock`, forked and adapted from [resque-lock-timeout](https://github.com/lantins/resque-lock-timeout/tree/v0.4.5).

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2010 Chris Wanstrath
+Copyright (c) 2010 Ryan Carver
+Copyright (c) 2010 Luke Antins
+
+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

@@ -0,0 +1,238 @@
+ActiveJob Lock
+===================
+
+An [ActiveJob][activejob] plugin that adds locking, with optional timeout/deadlock handling.
+
+Using a `lock_timeout` allows you to re-acquire the lock should your job
+fail, crash, or is otherwise unable to release the lock. **i.e.** Your server
+unexpectedly loses power. Very handy for jobs that are recurring or may be
+retried.
+
+**n.b.** By default, a job that fails to acquire a lock will be dropped. You can handle lock failures by implementing the available [callback](#callbacks).
+
+Usage / Examples
+----------------
+
+### Single Job Instance
+
+```ruby
+class UpdateNetworkGraph < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :network_graph
+
+  def perform(repo_id)
+    heavy_lifting
+  end
+end
+```
+
+Locking is achieved by storing a identifier/lock key in Redis.
+
+Default behavior...
+
+* Only one instance of a job may execute at once.
+* The lock is held until the job completes or fails.
+* If another job is executing with the same arguments the job will abort.
+
+Please see below for more information about the identifier/lock key.
+
+### Enqueued Exclusivity (Loner Option)
+
+Setting the `@loner` boolean to `true` will ensure the job is not enqueued if
+the job (identified by the `identifier` method) is already running/enqueued.
+
+```ruby
+class LonelyJob < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :loners
+  lock loner: true
+
+  def perform(repo_id)
+    heavy_lifting
+  end
+end
+```
+
+### Lock Expiry/Timeout
+
+The locking algorithm used can be found in the [Redis SETNX][redis-setnx]
+documentation.
+
+Simply set the lock timeout in seconds, e.g.
+
+```ruby
+class UpdateNetworkGraph < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :network_graph
+  # Lock may be held for up to an hour.
+  lock timeout: 3600
+
+  def perform(repo_id)
+    heavy_lifting
+  end
+end
+```
+
+Customize & Extend
+==================
+
+### Job Identifier/Lock Key
+
+By default the key uses this format: `lock:<job class name>:<identifier>`.
+
+The default identifier is just your job arguments joined with a dash `-`.
+
+If you have a lot of arguments or really long ones, you should consider
+overriding `identifier` to define a more precise or loose custom identifier:
+
+```ruby
+class UpdateNetworkGraph < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :network_graph
+
+  # Run only one at a time, regardless of repo_id.
+  def identifier(repo_id)
+    nil
+  end
+
+  def perform(repo_id)
+    heavy_lifting
+  end
+end
+```
+
+The above modification will ensure only one job of class
+UpdateNetworkGraph is running at a time, regardless of the
+repo_id.
+
+Its lock key would be: `lock:UpdateNetworkGraph` (the `:<identifier>` part is left out if the identifier is `nil`).
+
+You can define the entire key by overriding `redis_lock_key`:
+
+```ruby
+class UpdateNetworkGraph < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :network_graph
+
+  def redis_lock_key(repo_id)
+    "lock:updates"
+  end
+
+  def perform(repo_id)
+    heavy_lifting
+  end
+end
+```
+
+That would use the key `lock:updates`.
+
+### Redis Connection Used for Locking
+
+By default all locks are stored via a Redis client. For that, you have to tell `ActiveJobLock`
+which client it should use. Set that through an initializer:
+
+```ruby
+# config/initializers/active_job_lock.rb
+
+ActiveJobLock::Config.redis = Redis.new(redis_config)
+```
+
+If you want, you can then override it per job instance by doing:
+
+```ruby
+class UpdateNetworkGraph < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :network_graph
+
+  def lock_redis
+    @lock_redis ||= CustomRedis.new
+  end
+
+  def perform(repo_id)
+    heavy_lifting
+  end
+end
+```
+
+### Setting Timeout At Runtime
+
+You may define the `lock_timeout` method to adjust the timeout at runtime
+using job arguments. e.g.
+
+```ruby
+class UpdateNetworkGraph < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :network_graph
+
+  def lock_timeout(repo_id, timeout_minutes)
+    60 * timeout_minutes
+  end
+
+  def perform(repo_id, timeout_minutes = 1)
+    heavy_lifting
+  end
+end
+```
+
+### Helper Methods
+
+* `locked?` - checks if the lock is currently held.
+* `enqueued?` - checks if the loner lock is currently held.
+* `loner_locked?` - checks if the job is either enqueued (if a loner) or locked (any job).
+* `refresh_lock!` - Refresh the lock, useful for jobs that are taking longer
+    then usual but your okay with them holding on to the lock a little longer.
+
+### <a name="callbacks"></a> Callbacks
+
+Several callbacks are available to override and implement your own logic, e.g.
+
+```ruby
+class UpdateNetworkGraph < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  queue_as :network_graph
+  lock timeout: 3600, loner: true
+
+  # Job failed to acquire lock. You may implement retry or other logic.
+  def lock_failed(repo_id)
+    raise LockFailed
+  end
+
+  # Unable to enqueue job because its running or already enqueued.
+  def loner_enqueue_failed(repo_id)
+    raise EnqueueFailed
+  end
+
+  # Job has complete; but the lock expired before we could release it.
+  # The lock wasn't released; as its *possible* the lock is now held
+  # by another job.
+  def lock_expired_before_release(repo_id)
+    handle_if_needed
+  end
+
+  def perform(repo_id)
+    heavy_lifting
+  end
+end
+```
+
+Install
+=======
+
+    $ gem install active_job_lock
+
+Acknowledgements
+================
+
+Forked and adapted from Luke Antins' [resque-lock-timeout v0.4.5][resque-lock-timeout] plugin.
+
+[activejob]: https://github.com/rails/rails/tree/master/activejob
+[resque-lock-timeout]: https://github.com/lantins/resque-lock-timeout/tree/v0.4.5
+[redis-setnx]: http://redis.io/commands/setnx

data/Rakefile

@@ -0,0 +1,21 @@
+require 'rake/testtask'
+require 'yard'
+require 'yard/rake/yardoc_task'
+require 'bundler/gem_tasks'
+
+task :default => :test
+
+desc 'Run unit tests.'
+Rake::TestTask.new(:test) do |task|
+  task.test_files = FileList['test/*_test.rb']
+  task.verbose = true
+end
+
+desc 'Build Yardoc documentation.'
+YARD::Rake::YardocTask.new :yardoc do |t|
+    t.files   = ['lib/**/*.rb']
+    t.options = ['--output-dir', 'doc/',
+                 '--files', 'LICENSE,HISTORY.md',
+                 '--readme', 'README.md',
+                 '--title', 'active_job_lock documentation']
+end

data/lib/active_job_lock.rb

@@ -0,0 +1,5 @@
+require 'active_job_lock/config'
+require 'active_job_lock/core'
+
+module ActiveJobLock
+end

data/lib/active_job_lock/config.rb

@@ -0,0 +1,7 @@
+module ActiveJobLock
+  module Config
+    extend self
+
+    attr_accessor :redis
+  end
+end

data/lib/active_job_lock/core.rb

@@ -0,0 +1,314 @@
+module ActiveJobLock
+  # If you want only one instance of your job running at a time,
+  # include this module:
+  #
+  #   class UpdateNetworkGraph < ActiveJob::Base
+  #     include ActiveJobLock::Core
+  #     queue_as :network_graph
+  #
+  #     def perform(repo_id)
+  #       heavy_lifting
+  #     end
+  #   end
+  #
+  # If you wish to limit the duration a lock may be held for, you can
+  # set/override `lock_timeout`. e.g.
+  #
+  #   class UpdateNetworkGraph < ActiveJob::Base
+  #     include ActiveJobLock::Core
+  #     queue_as :network_graph
+  #
+  #     # lock may be held for upto an hour.
+  #     lock timeout: 3600
+  #
+  #     def perform(repo_id)
+  #       heavy_lifting
+  #     end
+  #   end
+  #
+  # If you wish that only one instance of the job defined by #identifier may be
+  # enqueued or running, you can set/override `loner`. e.g.
+  #
+  #   class PdfExport < ActiveJob::Base
+  #     include ActiveJobLock::Core
+  #     queue_as :exports
+  #
+  #     # only one job can be running/enqueued at a time. For instance a button
+  #     # to run a PDF export. If the user clicks several times on it, enqueue
+  #     # the job if and only if
+  #     #   - the same export is not currently running
+  #     #   - the same export is not currently queued.
+  #     # ('same' being defined by `identifier`)
+  #     lock loner: true
+  #
+  #     def perform(repo_id)
+  #       heavy_lifting
+  #     end
+  #   end
+  module Core
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      attr_accessor :lock_timeout, :loner
+
+      def lock(options = {})
+        self.lock_timeout = options[:timeout]
+        self.loner = options[:loner]
+      end
+    end
+
+    def initialize(*args)
+      super(*args)
+      self.extend(OverriddenMethods)
+    end
+
+    module OverriddenMethods
+      # @abstract
+      # if the job is a `loner`, enqueue only if no other same job
+      # is already running/enqueued
+      #
+      def enqueue(*_)
+        if loner
+          if loner_locked?(*arguments)
+            # Same job is currently running
+            loner_enqueue_failed(*arguments)
+            return
+          else
+            acquire_loner_lock!(*arguments)
+          end
+        end
+        super
+      end
+
+      # Where the magic happens.
+      #
+      def perform(*arguments)
+        lock_until = acquire_lock!(*arguments)
+
+        # Release loner lock as job has been dequeued
+        release_loner_lock!(*arguments) if loner
+
+        # Abort if another job holds the lock.
+        return unless lock_until
+
+        begin
+          super(*arguments)
+        ensure
+          # Release the lock on success and error. Unless a lock_timeout is
+          # used, then we need to be more careful before releasing the lock.
+          now = Time.now.to_i
+          if lock_until != true and lock_until < now
+            # Eeek! Lock expired before perform finished. Trigger callback.
+            lock_expired_before_release(*arguments)
+          else
+            release_lock!(*arguments)
+          end
+        end
+      end
+    end
+
+    private
+
+    # @abstract You may override to implement a custom identifier,
+    #           you should consider doing this if your job arguments
+    #           are many/long or may not cleanly cleanly to strings.
+    #
+    # Builds an identifier using the job arguments. This identifier
+    # is used as part of the redis lock key.
+    #
+    # @param [Array] args job arguments
+    # @return [String, nil] job identifier
+    def identifier(*args)
+      args.join('-')
+    end
+
+    # Override to fully control the redis object used for storing
+    # the locks.
+    #
+    # @return [Redis] redis object
+    def lock_redis
+      @lock_redis ||= ActiveJobLock::Config.redis
+    end
+
+    # Override to fully control the lock key used. It is passed
+    # the job arguments.
+    #
+    # The default looks like this: `lock:<class name>:<identifier>`
+    #
+    # @param [Array] args job arguments
+    # @return [String] redis key
+    def redis_lock_key(*args)
+      ['lock', self.class.name, identifier(*args)].compact.join(':')
+    end
+
+    # Builds lock key used by `@loner` option. Passed job arguments.
+    #
+    # The default looks like this: `loner:lock:<class name>:<identifier>`
+    #
+    # @param [Array] args job arguments
+    # @return [String] redis key
+    def redis_loner_lock_key(*args)
+      ['loner', redis_lock_key(*args)].compact.join(':')
+    end
+
+    # Number of seconds the lock may be held for.
+    # A value of 0 or below will lock without a timeout.
+    #
+    # @return [Fixnum]
+    def lock_timeout
+      @lock_timeout ||= self.class.lock_timeout || 0
+    end
+
+    # Whether one instance of the job should be running or enqueued.
+    #
+    # @return [TrueClass || FalseClass]
+    def loner
+      @loner ||= self.class.loner || false
+    end
+
+    # Checks if job is locked or loner locked (if applicable).
+    #
+    # @return [Boolean] true if the job is locked by someone
+    def loner_locked?(*args)
+      locked?(*args) || (loner && enqueued?(*args))
+    end
+
+    # Convenience method to check if job is locked and lock did not expire.
+    #
+    # @return [Boolean] true if the job is locked by someone
+    def locked?(*args)
+      inspect_lock(:redis_lock_key, *args)
+    end
+
+    # Convenience method to check if a loner job is queued and lock did not expire.
+    #
+    # @return [Boolean] true if the job is already queued
+    def enqueued?(*args)
+      inspect_lock(:redis_loner_lock_key, *args)
+    end
+
+    # Check for existence of given key.
+    #
+    # @param [Array] args job arguments
+    # @param [Symbol] lock_key_method the method returning redis key to lock
+    # @return [Boolean] true if the lock exists
+    def inspect_lock(lock_key_method, *args)
+      lock_until = lock_redis.get(self.send(lock_key_method, *args))
+      return (lock_until.to_i > Time.now.to_i) if lock_timeout > 0
+      !lock_until.nil?
+    end
+
+    # @abstract
+    # Hook method; called when unable to acquire the lock.
+    #
+    # @param [Array] args job arguments
+    def lock_failed(*args)
+    end
+
+    # @abstract
+    # Hook method; called when unable to enqueue loner job.
+    #
+    # @param [Array] args job arguments
+    def loner_enqueue_failed(*args)
+    end
+
+    # @abstract
+    # Hook method; called when the lock expired before we released it.
+    #
+    # @param [Array] args job arguments
+    def lock_expired_before_release(*args)
+    end
+
+    # Try to acquire a lock for running the job.
+    # @return [Boolean, Fixnum]
+    def acquire_lock!(*args)
+      acquire_lock_impl!(:redis_lock_key, :lock_failed, *args)
+    end
+
+    # Try to acquire a lock to enqueue a loner job.
+    # @return [Boolean, Fixnum]
+    def acquire_loner_lock!(*args)
+      acquire_lock_impl!(:redis_loner_lock_key, :loner_enqueue_failed, *args)
+    end
+
+    # Generic implementation of the locking logic
+    #
+    # Returns false; when unable to acquire the lock.
+    # * Returns true; when lock acquired, without a timeout.
+    # * Returns timestamp; when lock acquired with a timeout, timestamp is
+    #   when the lock timeout expires.
+    #
+    # @param [Symbol] lock_key_method the method returning redis key to lock
+    # @param [Symbol] failed_hook the method called if lock failed
+    # @param [Array] args job arguments
+    # @return [Boolean, Fixnum]
+    def acquire_lock_impl!(lock_key_method, failed_hook, *args)
+      acquired = false
+      lock_key = self.send(lock_key_method, *args)
+
+      unless lock_timeout > 0
+        # Acquire without using a timeout.
+        acquired = true if lock_redis.setnx(lock_key, true)
+      else
+        # Acquire using the timeout algorithm.
+        acquired, lock_until = acquire_lock_algorithm!(lock_key, *args)
+      end
+
+      self.send(failed_hook, *args) if !acquired
+      lock_until && acquired ? lock_until : acquired
+    end
+
+    # Attempts to acquire the lock using a timeout / deadlock algorithm.
+    #
+    # Locking algorithm: http://code.google.com/p/redis/wiki/SetnxCommand
+    #
+    # @param [String] lock_key redis lock key
+    # @param [Array] args job arguments
+    def acquire_lock_algorithm!(lock_key, *args)
+      now = Time.now.to_i
+      lock_until = now + lock_timeout
+      acquired = false
+
+      return [true, lock_until] if lock_redis.setnx(lock_key, lock_until)
+      # Can't acquire the lock, see if it has expired.
+      lock_expiration = lock_redis.get(lock_key)
+      if lock_expiration && lock_expiration.to_i < now
+        # expired, try to acquire.
+        lock_expiration = lock_redis.getset(lock_key, lock_until)
+        if lock_expiration.nil? || lock_expiration.to_i < now
+          acquired = true
+        end
+      else
+        # Try once more...
+        acquired = true if lock_redis.setnx(lock_key, lock_until)
+      end
+
+      [acquired, lock_until]
+    end
+
+    # Release the lock.
+    #
+    # @param [Array] args job arguments
+    def release_lock!(*args)
+      lock_redis.del(redis_lock_key(*args))
+    end
+
+    # Release the enqueue lock for loner jobs
+    #
+    # @param [Array] args job arguments
+    def release_loner_lock!(*args)
+      lock_redis.del(redis_loner_lock_key(*args))
+    end
+
+    # Refresh the lock.
+    #
+    # @param [Array] args job arguments
+    def refresh_lock!(*args)
+      now = Time.now.to_i
+      lock_until = now + lock_timeout
+      lock_redis.set(redis_lock_key(*args), lock_until)
+    end
+  end
+end

data/lib/active_job_lock/version.rb

@@ -0,0 +1,3 @@
+module ActiveJobLock
+  VERSION = '0.1.0'.freeze
+end

data/test/integration_test.rb

@@ -0,0 +1,60 @@
+require_relative 'test_helper'
+
+class IntegrationTest < Minitest::Test
+  include ActiveJob::TestHelper
+
+  def setup
+    @redis = ActiveJobLock::Config.redis
+    @redis.flushall
+  end
+
+  def test_jobs_same_args_running_in_parallel
+    r1 = r2 = nil
+
+    [
+      Thread.new { r1 = SlowJob.perform_now(1) },
+      Thread.new { sleep 0.01; r2 = SlowJob.perform_now(1) }
+    ].map(&:join)
+
+    assert_equal :performed, r1, 'First job should have been performed'
+    assert_equal nil, r2, 'Second job should not have been performed because first job had the lock'
+  end
+
+  def test_jobs_diff_args_running_in_parallel
+    r1 = r2 = nil
+
+    [
+      Thread.new { r1 = SlowJob.perform_now(1) },
+      Thread.new { sleep 0.01; r2 = SlowJob.perform_now(2) }
+    ].map(&:join)
+
+    assert_equal :performed, r1, 'First job should have been performed'
+    assert_equal :performed, r2, 'Second job should have been performed'
+  end
+
+  def test_jobs_same_args_running_in_parallel_with_timeout
+    r1 = r2 = nil
+
+    [
+      Thread.new { r1 = SuperSlowWithTimeoutJob.perform_now(1) },
+      Thread.new { sleep 2; r2 = SuperSlowWithTimeoutJob.perform_now(1) }
+    ].map(&:join)
+
+    assert_equal :performed, r1, 'First job should have been performed'
+    assert_equal :performed, r2, 'Second job should have been performed because the timeout has passed'
+  end
+
+  def test_lock_releasing_with_failing_jobs
+    FastJob.to_fail = true
+    assert_raises { FastJob.perform_now(1) }
+    FastJob.to_fail = false
+    assert_equal :performed, FastJob.perform_now(1), 'Should have been performed assuming that the first job released the lock'
+  end
+
+  def test_loner_jobs
+    LonerJob.perform_later
+    assert_enqueued_jobs 1
+    LonerJob.perform_later
+    assert_enqueued_jobs 1
+  end
+end

data/test/redis-test.conf

@@ -0,0 +1,115 @@
+# Redis configuration file example
+
+# By default Redis does not run as a daemon. Use 'yes' if you need it.
+# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
+daemonize yes
+
+# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
+# You can specify a custom pid file location here.
+#pidfile ./test/redis-test.pid
+
+# Accept connections on the specified port, default is 6379
+port 6379
+
+# If you want you can bind a single interface, if the bind option is not
+# specified all the interfaces will listen for connections.
+#
+# bind 127.0.0.1
+
+# Close the connection after a client is idle for N seconds (0 to disable)
+timeout 300
+
+# Save the DB on disk:
+#
+#   save <seconds> <changes>
+#
+#   Will save the DB if both the given number of seconds and the given
+#   number of write operations against the DB occurred.
+#
+#   In the example below the behaviour will be to save:
+#   after 900 sec (15 min) if at least 1 key changed
+#   after 300 sec (5 min) if at least 10 keys changed
+#   after 60 sec if at least 10000 keys changed
+#save 900 1
+#save 300 10
+#save 60 10000
+
+# The filename where to dump the DB
+#dbfilename dump.rdb
+
+# For default save/load DB in/from the working directory
+# Note that you must specify a directory not a file name.
+#dir ./test/
+
+# Set server verbosity to 'debug'
+# it can be one of:
+# debug (a lot of information, useful for development/testing)
+# notice (moderately verbose, what you want in production probably)
+# warning (only very important / critical messages are logged)
+loglevel debug
+
+# Specify the log file name. Also 'stdout' can be used to force
+# the demon to log on the standard output. Note that if you use standard
+# output for logging but daemonize, logs will be sent to /dev/null
+logfile stdout
+
+# Set the number of databases. The default database is DB 0, you can select
+# a different one on a per-connection basis using SELECT <dbid> where
+# dbid is a number between 0 and 'databases'-1
+databases 16
+
+################################# REPLICATION #################################
+
+# Master-Slave replication. Use slaveof to make a Redis instance a copy of
+# another Redis server. Note that the configuration is local to the slave
+# so for example it is possible to configure the slave to save the DB with a
+# different interval, or to listen to another port, and so on.
+
+# slaveof <masterip> <masterport>
+
+################################## SECURITY ###################################
+
+# Require clients to issue AUTH <PASSWORD> before processing any other
+# commands.  This might be useful in environments in which you do not trust
+# others with access to the host running redis-server.
+#
+# This should stay commented out for backward compatibility and because most
+# people do not need auth (e.g. they run their own servers).
+
+# requirepass foobared
+
+################################### LIMITS ####################################
+
+# Set the max number of connected clients at the same time. By default there
+# is no limit, and it's up to the number of file descriptors the Redis process
+# is able to open. The special value '0' means no limts.
+# Once the limit is reached Redis will close all the new connections sending
+# an error 'max number of clients reached'.
+
+# maxclients 128
+
+# Don't use more memory than the specified amount of bytes.
+# When the memory limit is reached Redis will try to remove keys with an
+# EXPIRE set. It will try to start freeing keys that are going to expire
+# in little time and preserve keys with a longer time to live.
+# Redis will also try to remove objects from free lists if possible.
+#
+# If all this fails, Redis will start to reply with errors to commands
+# that will use more memory, like SET, LPUSH, and so on, and will continue
+# to reply to most read-only commands like GET.
+#
+# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
+# 'state' server or cache, not as a real DB. When Redis is used as a real
+# database the memory usage will grow over the weeks, it will be obvious if
+# it is going to use too much memory in the long run, and you'll have the time
+# to upgrade. With maxmemory after the limit is reached you'll start to get
+# errors for write operations, and this may even lead to DB inconsistency.
+
+# maxmemory <bytes>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+# glueoutputbuf yes

data/test/test_helper.rb

@@ -0,0 +1,30 @@
+require 'minitest/pride'
+require 'minitest/autorun'
+
+require 'redis'
+require 'active_job'
+require 'active_job_lock'
+require_relative 'test_jobs'
+
+# make sure we can run redis-server
+if !system('which redis-server')
+  puts '', "** `redis-server` was not found in your PATH"
+  abort ''
+end
+
+# make sure we can shutdown the server using cli.
+if !system('which redis-cli')
+  puts '', "** `redis-cli` was not found in your PATH"
+  abort ''
+end
+
+puts "Starting redis for testing at localhost:6379..."
+
+# Start redis server for testing.
+`redis-server ./redis-test.conf`
+ActiveJobLock::Config.redis = Redis.new(host: '127.0.0.1', port: '6379')
+
+# After tests are complete, make sure we shutdown redis.
+Minitest.after_run {
+  `redis-cli -p 9737 shutdown nosave`
+}

data/test/test_jobs.rb

@@ -0,0 +1,49 @@
+# Job that executes quickly
+class FastJob < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  class << self
+    attr_accessor :to_fail
+  end
+
+  def perform(*_)
+    raise if fail?
+    :performed
+  end
+
+  def fail?
+    self.class.to_fail
+  end
+end
+
+# Slow successful job, does not use timeout algorithm.
+class SlowJob < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  def perform(*_)
+    sleep 1
+    return :performed
+  end
+end
+
+# Job that enables the timeout algorithm.
+class SuperSlowWithTimeoutJob < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  lock timeout: 1
+
+  def perform(*_)
+    sleep 3
+    return :performed
+  end
+end
+
+# Job that can be enqueued one at a time
+class LonerJob < ActiveJob::Base
+  include ActiveJobLock::Core
+
+  lock loner: true
+
+  def perform(*_)
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: active_job_lock
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Daniel Ferraz
+- Luke Antins
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: |2
+    An ActiveJob plugin. Adds locking, with optional timeout/deadlock handling.
+
+    Using a `lock_timeout` allows you to re-acquire the lock should your job
+    fail, crash, or is otherwise unable to relase the lock.
+
+    i.e. Your server unexpectedly looses power. Very handy for jobs that are
+    recurring or may be retried.
+email: ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- HISTORY.md
+- LICENSE
+- README.md
+- Rakefile
+- lib/active_job_lock.rb
+- lib/active_job_lock/config.rb
+- lib/active_job_lock/core.rb
+- lib/active_job_lock/version.rb
+- test/integration_test.rb
+- test/redis-test.conf
+- test/test_helper.rb
+- test/test_jobs.rb
+homepage: http://github.com/dferrazm/active_job_lock
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: An ActiveJob plugin to add locking, with optional timeout/deadlock handling.
+test_files: []
+has_rdoc: false