resque-unique_at_runtime 2.0.4 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8d2a39f3df5617304a84c059e96c8fc073ceb0ab4d7b0108bdd0382ab8914098
-  data.tar.gz: b5044b3d977f372f50f9d2186986ac64ca61c7a056ad01070b6b78e79af34dd6
+  metadata.gz: 645ac4f759c2b0721d782071985fdec3d14de968eeef88ae760c0a6e1deb0c67
+  data.tar.gz: f2a99e565e17ae87b290b8a834cfb9f6d5d9474fa7ae158eba361344f33c7850
 SHA512:
-  metadata.gz: b556a0c053fb7fb04c887e1eaf5788138a118c5e8e1b9dc6511772eea91f03fcce9d8b6b43304b884eadf443e6cd0b4afd5e2830e49eed5fe830d3b0c3503a30
-  data.tar.gz: 86d93234dd71c3aaa75da1956458217e422e4010c79ba876805ef52cc81f77bab02668ee57d12311a29d88dd9676f2a6ed12927215fd9c3c4335372476a7321a
+  metadata.gz: acbfec52b562d31dc543fa4de471700d485cc3654a0ab7813e07a68f029f7d6e43e953e3de849cca9f39f62359ea29b216b2dec3d0e9b3c8a1e9264c595ac777
+  data.tar.gz: 7941f8e4a0eabd5a222fd832b46f32f73b52b14ec4a94aa842ba948f26037cbc8b1d1c3e115dad91beba494aa40dd925aa26a8f598cb57e88227642ba337d68e

data/.rubocop.yml

@@ -0,0 +1,2 @@
+inherit_from: .rubocop_todo.yml
+TargetRubyVersion: 2.5

data/.rubocop_todo.yml

@@ -0,0 +1,75 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2018-11-07 04:06:03 -0800 using RuboCop version 0.59.0.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: Include.
+# Include: **/*.gemspec
+Gemspec/RequiredRubyVersion:
+  Exclude:
+    - 'resque-unique_at_runtime.gemspec'
+
+# Offense count: 1
+Metrics/AbcSize:
+  Max: 17
+
+# Offense count: 3
+# Configuration parameters: CountComments, ExcludedMethods.
+# ExcludedMethods: refine
+Metrics/BlockLength:
+  Max: 102
+
+# Offense count: 2
+# Configuration parameters: ExpectMatchingDefinition, Regex, IgnoreExecutableScripts, AllowedAcronyms.
+# AllowedAcronyms: CLI, DSL, ACL, API, ASCII, CPU, CSS, DNS, EOF, GUID, HTML, HTTP, HTTPS, ID, IP, JSON, LHS, QPS, RAM, RHS, RPC, SLA, SMTP, SQL, SSH, TCP, TLS, TTL, UDP, UI, UID, UUID, URI, URL, UTF8, VM, XML, XMPP, XSRF, XSS
+Naming/FileName:
+  Exclude:
+    - 'lib/resque-unique_at_runtime.rb'
+    - 'resque-unique_at_runtime.gemspec'
+
+# Offense count: 1
+# Configuration parameters: EnforcedStyle.
+# SupportedStyles: lowercase, uppercase
+Naming/HeredocDelimiterCase:
+  Exclude:
+    - 'resque-unique_at_runtime.gemspec'
+
+# Offense count: 1
+# Configuration parameters: MinNameLength, AllowNamesEndingInNumbers, AllowedNames, ForbiddenNames.
+# AllowedNames: io, id, to, by, on, in, at, ip, db
+Naming/UncommunicativeMethodParamName:
+  Exclude:
+    - 'lib/resque/plugins/unique_at_runtime.rb'
+
+# Offense count: 1
+# Configuration parameters: AllowedChars.
+Style/AsciiComments:
+  Exclude:
+    - 'lib/resque/plugins/unique_at_runtime.rb'
+
+# Offense count: 4
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/resque-unique_at_runtime.rb'
+    - 'lib/resque/plugins/unique_at_runtime.rb'
+    - 'lib/resque/unique_at_runtime/configuration.rb'
+    - 'lib/resque/unique_at_runtime/resque_ext/resque.rb'
+
+# Offense count: 1
+# Cop supports --auto-correct.
+# Configuration parameters: AllowAsExpressionSeparator.
+Style/Semicolon:
+  Exclude:
+    - 'spec/lib/unique_at_runtime_spec.rb'
+
+# Offense count: 26
+# Configuration parameters: AllowHeredoc, AllowURI, URISchemes, IgnoreCopDirectives, IgnoredPatterns.
+# URISchemes: http, https
+Metrics/LineLength:
+  Max: 120

data/Gemfile

@@ -1,15 +1,19 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 group :test do
-  gem 'rubocop', '~> 0.59.0'
-  gem 'rubocop-rspec', '~> 1.24.0'
-  gem 'byebug', '~> 10', platform: :mri, require: false
-  gem 'pry', '~> 0', platform: :mri, require: false
-  gem 'pry-byebug', '~> 3', platform: :mri, require: false
+  unless ENV['TRAVIS']
+    gem 'byebug', '~> 10', platform: :mri, require: false
+    gem 'pry', '~> 0', platform: :mri, require: false
+    gem 'pry-byebug', '~> 3', platform: :mri, require: false
+  end
+  gem 'rubocop', '~> 0.60.0'
+  gem 'rubocop-rspec', '~> 1.30.0'
   gem 'simplecov', '~> 0', require: false
 end
 
-# Specify your gem's dependencies in resque-unique_at_runtime.gemspec
+# Specify your gem's dependencies in unique_at_runtime.gemspec
 gemspec

data/README.md

@@ -63,7 +63,7 @@ Or install it yourself as:
     require 'resque-unique_at_runtime'
 
     class StrictlySerialJob
-      extend Resque::Plugins::UniqueAtRuntime
+      include Resque::Plugins::UniqueAtRuntime
 
       @queue = :serial_work
 
@@ -82,7 +82,7 @@ method.
     require 'resque-unique_at_runtime'
 
     class StrictlySerialJob
-      extend Resque::Plugins::UniqueAtRuntime
+      include Resque::Plugins::UniqueAtRuntime
 
       @queue = :serial_work
 
@@ -171,7 +171,7 @@ for its job (data x, data y, data z).
 
 #### Example #4 -- Requeue interval
 
-The behavior when multiple jobs exist in a queue protected by resque-unique_at_runtime
+The behavior when multiple jobs exist in a queue protected by `resque-unique_at_runtime`
 is for one job to be worked, while the other is continuously dequeued and
 requeued until the first job is finished.  This can result in that worker
 process pegging a CPU/core on a worker server.  To guard against this, the
@@ -185,7 +185,7 @@ in your job like so:
     require 'resque-unique_at_runtime'
 
     class StrictlySerialJob
-      extend Resque::Plugins::UniqueAtRuntime
+      include Resque::Plugins::UniqueAtRuntime
 
       @queue = :serial_work
       @runtime_requeue_interval = 5         # sleep for 5 seconds before requeueing
@@ -195,18 +195,26 @@ in your job like so:
       end
     end
 
+#### Example #5 -- Check if a job is running
+
+`resque-unique_at_runtime` extends `Resque` with a new method `running?`.
+
+It can tell you if a job with a specific signature is running, based on the
+ presence of the runtime uniqueness key.
+
+Caveat: It can be difficult to get the signature right, especially if you have
+tools that enhance job signatures with options.
+
 ## Contributing
 
+Bug reports and pull requests are welcome on GitHub at https://github.com/pboling/resque-unique_at_runtime. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
 1. Fork it
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
 
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/pboling/resque-unique_at_runtime. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
-
 ## Code of Conduct
 
 Everyone interacting in the Resque::Plugins::UniqueAtRuntime project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/pboling/resque-unique_at_runtime/blob/master/CODE_OF_CONDUCT.md).
@@ -226,10 +234,9 @@ dependency on this gem using the [Pessimistic Version Constraint][pvc] with two
 For example:
 
 ```ruby
-spec.add_dependency 'resque-unique_at_runtime', '~> 0.0'
+spec.add_dependency 'resque-unique_at_runtime', '~> 1.0'
 ```
 
-
 ## License
 
 * Copyright (c) 2012 Jonathan R. Wallace

data/Rakefile

@@ -1,8 +1,10 @@
 #!/usr/bin/env rake
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new
 
-task :default => :spec
-task :test => :spec
+task default: :spec
+task test: :spec

data/lib/resque-unique_at_runtime.rb

@@ -1,91 +1,74 @@
-require 'resque-unique_at_runtime/version'
+# frozen_string_literal: true
 
-module Resque
-  module Plugins
-    module UniqueAtRuntime
-      LOCK_TIMEOUT = 60 * 60 * 24 * 5
-      REQUEUE_INTERVAL = 1
-      
-      def runtime_lock_timeout_at(now)
-        now + runtime_lock_timeout + 1
-      end
+require 'resque/unique_at_runtime/version'
 
-      def runtime_lock_timeout
-        self.instance_variable_get(:@runtime_lock_timeout) || LOCK_TIMEOUT
-      end
+# Ruby Std Lib
+require 'digest/md5'
 
-      def runtime_requeue_interval
-        self.instance_variable_get(:@runtime_requeue_interval) || REQUEUE_INTERVAL
-      end
+# External Gems
+require 'colorized_string'
+require 'resque'
 
-      # Overwrite this method to uniquely identify which mutex should be used
-      # for a resque worker.
-      def unique_at_runtime_redis_key(*_)
-        puts "resque-unique_at_runtime: getting key for #{@queue}!" if ENV['RESQUE_DEBUG']
-        "resque-unique_at_runtime:#{@queue}"
-      end
+# This Gem
+require 'resque/plugins/unique_at_runtime'
+require 'resque/unique_at_runtime/resque_ext/resque'
+require 'resque/unique_at_runtime/configuration'
 
-      def can_lock_queue?(*args)
-        queue_locked?(*args) == false ? true : false
-      end
-      
-      def queue_locked?(*args)
-        now = Time.now.to_i
-        key = unique_at_runtime_redis_key(*args)
-        timeout = runtime_lock_timeout_at(now)
+# See lib/resque/plugins/unique_at_runtime.rb for the actual plugin
+#
+# This is not that ^.  Rather, it is an API used by the plugin or as tools by a
+#   developer.  These methods are not intended to be included/extended into
+#   Resque, Resque::Job, or Resque::Queue.
+module Resque
+  module UniqueAtRuntime
+    PLUGIN_TAG = (ColorizedString['[R-UAR] '].blue).freeze
 
-        puts "resque-unique_at_runtime: attempting to lock queue with #{key}" if ENV['RESQUE_DEBUG']
+    def runtime_unique_log(message, config_proxy = nil)
+      config_proxy ||= uniqueness_configuration
+      config_proxy.unique_logger&.send(config_proxy.unique_log_level, message)
+    end
 
-        # Per http://redis.io/commands/setnx
-        return false if Resque.redis.setnx(key, timeout)
-        return key if Resque.redis.get(key).to_i > now
-        return false if Resque.redis.getset(key, timeout).to_i <= now
-        return key
-      end
+    def runtime_unique_debug(message, config_proxy = nil)
+      config_proxy ||= uniqueness_configuration
+      config_proxy.unique_logger&.debug("#{PLUGIN_TAG}#{message}") if config_proxy.debug_mode
+    end
 
-      def unlock_queue(*args)
-        key = unique_at_runtime_redis_key(*args)
-        puts "resque-unique_at_runtime: unlock queue with #{key}" if ENV['RESQUE_DEBUG']
-        Resque.redis.del(key)
-      end
+    # There are times when the class will need access to the configuration object,
+    #   such as to override it per instance method
+    def uniq_config
+      @uniqueness_configuration
+    end
 
-      def reenqueue(*args)
-        Resque.enqueue(self, *args)
-      end
+    # For per-class config with a block
+    def uniqueness_configure
+      @uniqueness_configuration ||= Configuration.new
+      yield(@uniqueness_configuration)
+    end
 
-      def before_perform_lock_runtime(*args)
-        if (key = queue_locked?(*args))
-          puts "resque-unique_at_runtime: failed to lock queue with #{key}" if ENV['RESQUE_DEBUG']
+    #### CONFIG ####
+    class << self
+      attr_accessor :uniqueness_configuration
+    end
+    def uniqueness_config_reset(config = Configuration.new)
+      @uniqueness_configuration = config
+    end
 
-          # Sleep so the CPU's rest
-          sleep(runtime_requeue_interval)
+    def uniqueness_log_level
+      @uniqueness_configuration.log_level
+    end
 
-          # can't get the lock, so re-enqueue the task
-          reenqueue(*args)
+    def uniqueness_log_level=(log_level)
+      @uniqueness_configuration.log_level = log_level
+    end
 
-          # and don't perform
-          raise Resque::Job::DontPerform
-        else
-          puts "will perform"
-          true
-        end
-      end
+    self.uniqueness_configuration = Configuration.new # setup defaults
 
-      def around_perform_unlock_runtime(*args)
-        begin
-          yield
-        ensure
-          unlock_queue(*args)
-        end
-      end
-      
-      # There may be scenarios where the around_perform's ensure unlock 
-      #   duplicates the on_failure unlock, but that's a small price to pay for 
-      #   uniqueness.
-      def on_failure_unlock_runtime(*args)
-        puts "resque-unique_at_runtime: on failure unlock" if ENV['RESQUE_DEBUG']
-        unlock_queue(*args)
-      end
-    end
+    module_function(:runtime_unique_log,
+                    :runtime_unique_debug,
+                    :uniq_config,
+                    :uniqueness_configure,
+                    :uniqueness_config_reset,
+                    :uniqueness_log_level,
+                    :uniqueness_log_level=)
   end
 end

data/lib/resque/plugins/unique_at_runtime.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Resque
+  module Plugins
+    # If you want your job to support uniqueness at runtime, simply include
+    #   this module into your job class.
+    #
+    #   class RunAlone
+    #     @queue = :run_alone
+    #     include Resque::Plugins::UniqueAtRuntime
+    #
+    #     def self.perform(arg1, arg2)
+    #       alone_stuff
+    #     end
+    #   end
+    #
+    module UniqueAtRuntime
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      module ClassMethods
+        def runtime_lock_timeout_at(now)
+          now + runtime_lock_timeout + 1
+        end
+
+        def runtime_lock_timeout
+          instance_variable_get(:@runtime_lock_timeout) || Resque::UniqueAtRuntime.uniq_config&.lock_timeout
+        end
+
+        def runtime_requeue_interval
+          instance_variable_get(:@runtime_requeue_interval) || Resque::UniqueAtRuntime.uniq_config&.requeue_interval
+        end
+
+        # Overwrite this method to uniquely identify which mutex should be used
+        # for a resque worker.
+        def unique_at_runtime_redis_key(*_)
+          Resque::UniqueAtRuntime.runtime_unique_debug("getting key for #{@queue}!")
+          "#{unique_at_runtime_key_base}:#{@queue}"
+        end
+
+        # returns true if the job signature can be locked (is not currently locked)
+        def can_lock_queue?(*args)
+          !queue_locked?(*args)
+        end
+
+        # returns the locking key if locked, otherwise false
+        def queue_locked?(*args)
+          now = Time.now.to_i
+          key = unique_at_runtime_redis_key(*args)
+          timeout = runtime_lock_timeout_at(now)
+
+          Resque::UniqueAtRuntime.runtime_unique_debug("attempting to lock queue with #{key}")
+
+          # Per http://redis.io/commands/setnx
+          return false if Resque.redis.setnx(key, timeout)
+          return key if Resque.redis.get(key).to_i > now
+          return false if Resque.redis.getset(key, timeout).to_i <= now
+
+          key
+        end
+
+        def unlock_queue(*args)
+          key = unique_at_runtime_redis_key(*args)
+          Resque::UniqueAtRuntime.runtime_unique_debug("unlock queue with #{key}")
+          Resque.redis.del(key)
+        end
+
+        def reenqueue(*args)
+          Resque.enqueue(self, *args)
+        end
+
+        def before_perform_lock_runtime(*args)
+          if (key = queue_locked?(*args))
+            Resque::UniqueAtRuntime.runtime_unique_debug("failed to lock queue with #{key}")
+
+            # Sleep so the CPU's rest
+            sleep(runtime_requeue_interval)
+
+            # can't get the lock, so re-enqueue the task
+            reenqueue(*args)
+
+            # and don't perform
+            raise Resque::Job::DontPerform
+          else
+            Resque::UniqueAtRuntime.runtime_unique_debug('check passed will perform')
+            true
+          end
+        end
+
+        def around_perform_unlock_runtime(*args)
+          yield
+        ensure
+          unlock_queue(*args)
+        end
+
+        # There may be scenarios where the around_perform's ensure unlock±
+        #   duplicates the on_failure unlock, but that's a small price to pay for
+        #   uniqueness.
+        def on_failure_unlock_runtime(*args)
+          Resque::UniqueAtRuntime.runtime_unique_debug('on failure unlock')
+          unlock_queue(*args)
+        end
+
+        def unique_at_runtime_key_base
+          instance_variable_get(:@unique_at_runtime_key_base) || Resque::UniqueAtRuntime.uniq_config&.unique_at_runtime_key_base
+        end
+      end
+    end
+  end
+end

data/lib/resque/unique_at_runtime/configuration.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'logger'
+module Resque
+  module UniqueAtRuntime
+    class Configuration
+      DEFAULT_AT_RUNTIME_KEY_BASE = 'r-uae'
+      DEFAULT_LOCK_TIMEOUT = 60 * 60 * 24 * 5
+      DEFAULT_REQUEUE_INTERVAL = 1
+
+      attr_accessor :logger,
+                    :log_level,
+                    :unique_at_runtime_key_base,
+                    :lock_timeout,
+                    :requeue_interval,
+                    :debug_mode
+      def initialize(**options)
+        @logger = options.key?(:logger) ? options[:logger] : Logger.new(STDOUT)
+        @log_level = options.key?(:log_level) ? options[:log_level] : :debug
+        @unique_at_runtime_key_base = options.key?(:unique_at_runtime_key_base) ? options[:unique_at_runtime_key_base] : DEFAULT_AT_RUNTIME_KEY_BASE
+        @lock_timeout = options.key?(:lock_timeout) ? options[:lock_timeout] : DEFAULT_LOCK_TIMEOUT
+        @requeue_interval = options.key?(:requeue_interval) ? options[:requeue_interval] : DEFAULT_REQUEUE_INTERVAL
+        env_debug = ENV['RESQUE_DEBUG']
+        @debug_mode = options.key?(:debug_mode) ? options[:debug_mode] : env_debug == 'true' || (env_debug.is_a?(String) && env_debug.match?(/runtime/))
+      end
+
+      def unique_logger
+        logger
+      end
+
+      def unique_log_level
+        log_level
+      end
+
+      def log(msg)
+        Resque::UniqueAtRuntime.runtime_unique_log(msg, self)
+      end
+
+      def to_hash
+        {
+          logger: logger,
+          log_level: log_level
+        }
+      end
+    end
+  end
+end

data/lib/resque/unique_at_runtime/resque_ext/resque.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Resque
+  class << self
+    def running?(klass, *args)
+      klass.queue_locked?(*args)
+    end
+  end
+end

data/lib/resque/unique_at_runtime/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Resque
+  module UniqueAtRuntime
+    VERSION = '3.0.0'
+  end
+end

data/resque-unique_at_runtime.gemspec

@@ -1,43 +1,54 @@
-# -*- encoding: utf-8 -*-
-require File.expand_path('../lib/resque-unique_at_runtime/version', __FILE__)
-
-Gem::Specification.new do |gem|
-  gem.authors       = ["Peter H. Boling","Jonathan R. Wallace"]
-  gem.email         = ["peter.boling@gmail.com","jonathan.wallace@gmail.com"]
-  gem.summary       = %q{A resque plugin that ensures job uniqueness at runtime.}
-  gem.homepage      = "http://github.com/pboling/resque-unique_at_runtime"
-
-  gem.files         = `git ls-files`.split($\)
-  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
-  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.name          = "resque-unique_at_runtime"
-  gem.require_paths = ["lib"]
-  gem.version       = Resque::Plugins::UniqueAtRuntime::VERSION
-  gem.license       = "MIT"
-  gem.required_ruby_version = ">= 1.9.3"
-
-  gem.add_dependency 'resque', '>= 1.2'
-  gem.add_development_dependency 'mock_redis'
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec', '>= 3.0'
-  gem.add_development_dependency 'timecop'
-
-  gem.description   = <<desc
-Ensures that for a given queue, only one worker is working on a job at any given time.
-
-Example:
-
-  require 'resque/plugins/unique_at_runtime'
-
-  class StrictlySerialJob
-    extend Resque::Plugins::UniqueAtRuntime
-
-    @queue = :serial_work
-
-    def self.perform
-      # only one at a time in this block, no parallelism allowed for this
-      # particular queue
-    end
+# frozen_string_literal: true
+
+require File.expand_path('lib/resque/unique_at_runtime/version', __dir__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'resque-unique_at_runtime'
+  spec.version       = Resque::UniqueAtRuntime::VERSION
+  spec.authors       = ['Peter H. Boling', 'Jonathan R. Wallace']
+  spec.email         = ['peter.boling@gmail.com', 'jonathan.wallace@gmail.com']
+  spec.license       = 'MIT'
+
+  spec.summary       = 'A resque plugin that ensures job uniqueness at runtime.'
+  spec.homepage      = 'http://github.com/pboling/resque-unique_at_runtime'
+  spec.required_ruby_version = '>= 2.3'
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
   end
-desc
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'colorize', '~> 0.8'
+  spec.add_runtime_dependency 'resque', '>= 1.2'
+
+  spec.add_development_dependency 'fakeredis', '~> 0.7'
+  spec.add_development_dependency 'rake', '~> 12.3'
+  spec.add_development_dependency 'rspec', '>= 3.0'
+  spec.add_development_dependency 'rspec-block_is_expected', '~> 1.0'
+  spec.add_development_dependency 'rspec-stubbed_env', '~> 1.0'
+  spec.add_development_dependency 'timecop'
+
+  spec.add_development_dependency 'pry', '~> 0.11'
+  spec.add_development_dependency 'pry-byebug', '~> 3.6'
+  spec.add_development_dependency 'rubocop', '~> 0.60'
+  spec.add_development_dependency 'rubocop-rspec', '~> 1.30'
+
+  spec.description = <<~desc
+    Ensures that for a given queue, only one worker is working on a job at any given time.
+
+    Example:
+
+      require 'resque/plugins/unique_at_runtime'
+
+      class StrictlySerialJob
+        include Resque::Plugins::UniqueAtRuntime
+
+        @queue = :serial_work
+
+        def self.perform
+          # only one at a time in this block, no parallelism allowed for this
+          # particular queue
+        end
+      end
+  desc
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-unique_at_runtime
 version: !ruby/object:Gem::Version
-  version: 2.0.4
+  version: 3.0.0
 platform: ruby
 authors:
 - Peter H. Boling
@@ -9,8 +9,22 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-09-10 00:00:00.000000000 Z
+date: 2018-11-08 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
 - !ruby/object:Gem::Dependency
   name: resque
   requirement: !ruby/object:Gem::Requirement
@@ -26,33 +40,33 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
-  name: mock_redis
+  name: fakeredis
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '12.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -67,6 +81,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-block_is_expected
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-stubbed_env
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: timecop
   requirement: !ruby/object:Gem::Requirement
@@ -81,6 +123,62 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.60'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.60'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.30'
 description: |
   Ensures that for a given queue, only one worker is working on a job at any given time.
 
@@ -89,7 +187,7 @@ description: |
     require 'resque/plugins/unique_at_runtime'
 
     class StrictlySerialJob
-      extend Resque::Plugins::UniqueAtRuntime
+      include Resque::Plugins::UniqueAtRuntime
 
       @queue = :serial_work
 
@@ -106,6 +204,8 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
 - ".ruby-version"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
@@ -114,10 +214,11 @@ files:
 - README.md
 - Rakefile
 - lib/resque-unique_at_runtime.rb
-- lib/resque-unique_at_runtime/version.rb
+- lib/resque/plugins/unique_at_runtime.rb
+- lib/resque/unique_at_runtime/configuration.rb
+- lib/resque/unique_at_runtime/resque_ext/resque.rb
+- lib/resque/unique_at_runtime/version.rb
 - resque-unique_at_runtime.gemspec
-- spec/lib/unique_at_runtime_spec.rb
-- spec/spec_helper.rb
 homepage: http://github.com/pboling/resque-unique_at_runtime
 licenses:
 - MIT
@@ -130,7 +231,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: '2.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -142,6 +243,4 @@ rubygems_version: 2.7.7
 signing_key: 
 specification_version: 4
 summary: A resque plugin that ensures job uniqueness at runtime.
-test_files:
-- spec/lib/unique_at_runtime_spec.rb
-- spec/spec_helper.rb
+test_files: []

data/lib/resque-unique_at_runtime/version.rb

@@ -1,7 +0,0 @@
-module Resque
-  module Plugins
-    module UniqueAtRuntime
-      VERSION = "2.0.4"
-    end
-  end
-end

data/spec/lib/unique_at_runtime_spec.rb

@@ -1,180 +0,0 @@
-require 'spec_helper'
-
-class SerialJob
-  extend Resque::Plugins::UniqueAtRuntime
-  @queue = :serial_work
-
-  def self.perform(*args); end
-end
-
-class SerialJobWithCustomRedisKey
-  extend Resque::Plugins::UniqueAtRuntime
-  @queue = :serial_work
-
-  def self.unique_at_runtime_redis_key(account_id, *args)
-    "unique_at_runtime:#{@queue}:#{account_id}"
-  end
-
-  def self.perform(account_id, *args); end
-end
-
-describe Resque::Plugins::UniqueAtRuntime do
-  before do
-    Resque.redis.flushall
-  end
-
-  describe ".runtime_requeue_interval" do
-    it "should default to 5" do
-      expect(SerialJob.runtime_requeue_interval).to eql(1)
-    end
-
-    it "should be overridable with a class instance var" do
-      SerialJob.instance_variable_set(:@runtime_requeue_interval, 5)
-      expect(SerialJob.runtime_requeue_interval).to eql(5)
-    end
-  end
-
-  describe ".can_lock_queue?" do
-    it 'can lock a queue' do
-      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
-    end
-
-    it 'cannot lock an already locked queue' do
-      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
-      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(false)
-    end
-
-    it 'cannot lock a queue with active lock' do
-      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
-      Timecop.travel(Date.today + 1) do
-        expect(SerialJob.can_lock_queue?(:serial_work)).to eql(false)
-      end
-    end
-
-    it 'can relock a queue with expired lock' do
-      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
-
-      Timecop.travel(Date.today + 10) do
-        expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
-      end
-    end
-
-    it 'solves race condition with getset' do
-      expect(SerialJob.can_lock_queue?(:serial_work)).to eql(true)
-
-      Timecop.travel(Date.today + 10) do
-        threads = (1..10).to_a.map {
-          Thread.new {
-            Thread.current[:locked] = SerialJob.can_lock_queue?(:serial_work)
-          }
-        }
-
-        # Only one worker should acquire lock
-        locks = threads.map {|t| t.join; t[:locked] }
-        expect(locks.count(true)).to eql(1)
-      end
-    end
-  end
-
-  describe ".perform" do
-    before do
-      SerialJob.instance_variable_set(:@runtime_requeue_interval, 0)
-    end
-
-    describe "using the default redis key" do
-      it 'should lock and unlock the queue' do
-        job = Resque::Job.new(:serial_work, { 'class' => 'SerialJob', 'args' => %w[account_one job_one] })
-
-        # job is the first SerialJob to run so it can lock the queue and perform
-        expect(SerialJob).to receive(:queue_locked?).and_return(false)
-
-        # but it should also clean up after itself
-        expect(SerialJob).to receive(:unlock_queue)
-
-        job.perform
-      end
-
-      it 'should clean up lock even with catastrophic job failure' do
-        job = Resque::Job.new(:serial_work, { 'class' => 'SerialJob', 'args' => %w[account_one job_one] })
-
-        # job is the first SerialJob to run so it can lock the queue and perform
-        expect(SerialJob).to receive(:queue_locked?).and_return(false)
-
-        # but we have a catastrophic job failure
-        expect(SerialJob).to receive(:perform).and_raise(Exception)
-
-        # and still it should clean up after itself
-        expect(SerialJob).to receive(:unlock_queue).at_least(1).times
-
-        # unfortunately, the job will be lost but resque doesn't guarantee jobs
-        # aren't lost
-        expect { job.perform }.to raise_error(Exception)
-      end
-
-      it 'should place self at the end of the queue if unable to acquire the lock' do
-        job1_payload = %w[account_one job_one]
-        job2_payload = %w[account_one job_two]
-        Resque::Job.create(:serial_work, 'SerialJob', job1_payload)
-        Resque::Job.create(:serial_work, 'SerialJob', job2_payload)
-
-        expect(SerialJob).to receive(:queue_locked?).and_return(true)
-
-        # perform returns false when DontPerform exception is raised in
-        # before_perform callback
-        job1 = Resque.reserve(:serial_work)
-        expect(job1.perform).to eql(false)
-
-        first_queue_element = Resque.reserve(:serial_work)
-        expect(first_queue_element.payload["args"]).to eql([job2_payload])
-      end
-    end
-
-    describe "with a custom unique_at_runtime_redis_key" do
-      it 'should lock and unlock the queue' do
-        job = Resque::Job.new(:serial_work, { 'class' => 'SerialJobWithCustomRedisKey', 'args' => %w[account_one job_one] })
-
-        # job is the first SerialJobWithCustomRedisKey to run so it can lock the queue and perform
-        expect(SerialJobWithCustomRedisKey).to receive(:queue_locked?).and_return(false)
-
-        # but it should also clean up after itself
-        expect(SerialJobWithCustomRedisKey).to receive(:unlock_queue)
-
-        job.perform
-      end
-
-      it 'should clean up lock even with catastrophic job failure' do
-        job = Resque::Job.new(:serial_work, { 'class' => 'SerialJobWithCustomRedisKey', 'args' => %w[account_one job_one] })
-
-        # job is the first SerialJobWithCustomRedisKey to run so it can lock the queue and perform
-        expect(SerialJobWithCustomRedisKey).to receive(:queue_locked?).and_return(false)
-
-        # but we have a catastrophic job failure
-        expect(SerialJobWithCustomRedisKey).to receive(:perform).and_raise(Exception)
-
-        # and still it should clean up after itself
-        expect(SerialJobWithCustomRedisKey).to receive(:unlock_queue).at_least(1).times
-
-        # unfortunately, the job will be lost but resque doesn't guarantee jobs
-        # aren't lost
-        expect { job.perform }.to raise_error(Exception)
-      end
-
-      it 'should place self at the end of the queue if unable to acquire the lock' do
-        job1_payload = %w[account_one job_one]
-        job2_payload = %w[account_one job_two]
-        Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', job1_payload)
-        Resque::Job.create(:serial_work, 'SerialJobWithCustomRedisKey', job2_payload)
-
-        expect(SerialJobWithCustomRedisKey).to receive(:queue_locked?).and_return(true)
-
-        # perform returns false when DontPerform exception is raised in
-        # before_perform callback
-        job1 = Resque.reserve(:serial_work)
-        expect(job1.perform).to eql(false)
-
-        first_queue_element = Resque.reserve(:serial_work)
-        expect(first_queue_element.payload["args"]).to eql([job2_payload])
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,19 +0,0 @@
-require 'rspec'
-
-require 'mock_redis'
-require 'resque'
-require 'timecop'
-
-require 'byebug' if RbConfig::CONFIG['RUBY_INSTALL_NAME'] == 'ruby'
-
-require 'simplecov'
-SimpleCov.start
-
-# This gem
-require 'resque-unique_at_runtime'
-
-RSpec.configure do |config|
-  config.before(:suite) do
-    Resque.redis = MockRedis.new
-  end
-end