resque-unique_in_queue 1.0.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e2b27c8cf85da28ed578801b934b56a5865ea25518013b904379faf98f5ee7c
-  data.tar.gz: 2b4cc6f023e5b6c54fe80f5b0adbb026fc93e8510830e5b39f129272d5f3d95d
+  metadata.gz: 48f097b477503dbe4a6028c2587476e1a0bc45f53627d77aa3a2dc0b461edf59
+  data.tar.gz: b2134a95053feb956cba28906cf98aad1158556ce75c486a98ee5cd243f58301
 SHA512:
-  metadata.gz: 111c91bbb3c9fd405c528c95276e548355a144d54e220f8889866664c67adeea634438b8ed268d1b1fab9901b777612449681c76bcbe1d18f35323ec4efadc92
-  data.tar.gz: 7a1757c1e3ff7d3c56bccaddc14b38b635fe57b3fdcd6dc213b4e08864d85b1897122d081708c4c3e6185918599ae22b3bc7ceb57407ddb49314f78670f7e163
+  metadata.gz: f5e2e3bb2738e06343e50a2ff81f9fc5075227f5ed2f5ba8b550173056b90fe4e0a095334a61347b04e5520ec9df88ab06e022879cebf1cf7b00a380fecf5fbc
+  data.tar.gz: 020f470aa13f3c8a4f3b3575d98cdd27e87983422f73ee7e91dee2e53bdd95be98e58582b978d0eb91fed89acf33bf925a5cab84ba3319b1ba3f31620cd034e7

data/README.md

@@ -33,6 +33,26 @@ gem 'resque-unique_in_queue'
 
 ## Usage
 
+`resque-unique_in_queue` utilizes 3 class instance variables that can be set
+in your Jobs, in addition to the standard `@queue`.  Here they are, with their
+default values:
+
+```ruby
+@lock_after_execution_period = 0
+@ttl = -1
+@unique_in_queue_key_base = 'r-uiq'.freeze
+```
+
+The last one, in normal circumstances, shouldn't be set as different per class,
+or uniqueness cleanup becomes more difficult.
+
+It should be set only once, globally:
+
+```ruby
+Resque::UniqueInQueue.configuration.unique_in_queue_key_base = 'my-custom'
+```
+
+
 ```ruby
 class UpdateCat
   include Resque::Plugins::UniqueInQueue

data/lib/resque-unique_in_queue.rb

@@ -25,62 +25,27 @@ module Resque
   module UniqueInQueue
     PLUGIN_TAG = (ColorizedString['[R-UIQ] '].blue).freeze
 
-    def in_queue_unique_log(message, config_proxy = nil)
-      config_proxy ||= uniqueness_configuration
-      config_proxy.unique_logger&.send(config_proxy.unique_log_level, message) if config_proxy.unique_logger
+    def log(message)
+      configuration.logger&.send(configuration.log_level, message) if configuration.logger
     end
 
-    def in_queue_unique_debug(message, config_proxy = nil)
-      config_proxy ||= uniqueness_configuration
-      config_proxy.unique_logger&.debug("#{PLUGIN_TAG}#{message}") if config_proxy.debug_mode
-    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
+    def debug(message)
+      configuration.logger&.debug("#{PLUGIN_TAG}#{message}") if configuration.debug_mode
     end
 
     # For per-class config with a block
-    def uniqueness_configure
-      @uniqueness_configuration ||= Configuration.new
-      yield(@uniqueness_configuration)
+    def configure
+      yield(@configuration)
     end
 
     #### CONFIG ####
     class << self
-      attr_accessor :uniqueness_configuration
-    end
-    def uniqueness_config_reset(config = Configuration.new)
-      @uniqueness_configuration = config
-    end
-
-    def uniqueness_log_level
-      @uniqueness_configuration.log_level
-    end
-
-    def uniqueness_log_level=(log_level)
-      @uniqueness_configuration.log_level = log_level
-    end
-
-    def unique_in_queue_key_base
-      Configuration.unique_in_queue_key_base
-    end
-
-    def unique_in_queue_key_base=(key_base)
-      Configuration.unique_in_queue_key_base = key_base
+      attr_accessor :configuration
     end
 
-    self.uniqueness_configuration = Configuration.new # setup defaults
+    self.configuration = Configuration.instance # setup defaults
 
-    module_function(:in_queue_unique_log,
-                    :in_queue_unique_debug,
-                    :uniq_config,
-                    :uniqueness_configure,
-                    :uniqueness_config_reset,
-                    :uniqueness_log_level,
-                    :uniqueness_log_level=,
-                    :unique_in_queue_key_base,
-                    :unique_in_queue_key_base=)
+    module_function(:log,
+                    :debug)
   end
 end

data/lib/resque/plugins/unique_in_queue.rb

@@ -35,36 +35,40 @@ module Resque
           Digest::MD5.hexdigest Resque.encode(class: job, args: args)
         end
 
-        # The default ttl of a locking key is -1 (forever).
-        # To expire the lock after a certain amount of time, set a ttl (in seconds).
+        # The default ttl of a persisting key is 0, i.e. immediately deleted.
+        # Set lock_after_execution_period to block the execution
+        # of the job for a certain amount of time (in seconds).
         # For example:
         #
         # class FooJob
         #   include Resque::Plugins::UniqueInQueue
-        #   @ttl = 40
+        #   @lock_after_execution_period = 40
         # end
-        def ttl
-          @ttl ||= Resque::UniqueInQueue.uniq_config&.ttl
+        def lock_after_execution_period
+          instance_variable_get(:@lock_after_execution_period) ||
+              instance_variable_set(:lock_after_execution_period, Resque::UniqueInQueue.configuration&.lock_after_execution_period)
         end
 
-        # The default ttl of a persisting key is 0, i.e. immediately deleted.
-        # Set lock_after_execution_period to block the execution
-        # of the job for a certain amount of time (in seconds).
+        # The default ttl of a locking key is -1 (forever).
+        # To expire the lock after a certain amount of time, set a ttl (in seconds).
         # For example:
         #
         # class FooJob
         #   include Resque::Plugins::UniqueInQueue
-        #   @lock_after_execution_period = 40
+        #   @ttl = 40
         # end
-        def lock_after_execution_period
-          @lock_after_execution_period ||= Resque::UniqueInQueue.uniq_config&.lock_after_execution_period
+        def ttl
+          instance_variable_get(:@ttl) ||
+              instance_variable_set(:ttl, Resque::UniqueInQueue.configuration&.ttl)
         end
 
-        # Can't be overridden per each class because it wouldn't make sense.
+        # Should not generally be overridden per each class because it wouldn't
+        #   make sense.
         # It wouldn't be able to determine or enforce uniqueness across queues,
         #   and general cleanup of stray keys would be nearly impossible.
         def unique_in_queue_key_base
-          Resque::UniqueInQueue.uniq_config&.unique_in_queue_key_base
+          instance_variable_get(:@unique_in_queue_key_base) ||
+              instance_variable_set(:@unique_in_queue_key_base, Resque::UniqueInQueue.configuration&.unique_in_queue_key_base)
         end
       end
     end

data/lib/resque/unique_in_queue/configuration.rb

@@ -2,55 +2,53 @@ require 'logger'
 module Resque
   module UniqueInQueue
     class Configuration
-      DEFAULT_IN_QUEUE_KEY_BASE = 'r-uiq'.freeze
       DEFAULT_LOCK_AFTER_EXECUTION_PERIOD = 0
       DEFAULT_TTL = -1
+      DEFAULT_UNIQUE_IN_QUEUE_KEY_BASE = 'r-uiq'.freeze
+      DEFAULT_LOG_LEVEL = :debug
 
-      attr_accessor :logger,
-                    :log_level,
+      include Singleton
+
+      attr_accessor :debug_mode,
                     :lock_after_execution_period,
+                    :log_level,
+                    :logger,
                     :ttl,
-                    :debug_mode
-
-      class << self
-        attr_accessor :unique_in_queue_key_base
-      end
-      # Normally isn't set per job, so it can match across all queued jobs.
-      @unique_in_queue_key_base = DEFAULT_IN_QUEUE_KEY_BASE
-
-      def initialize(**options)
-        @logger = options.key?(:logger) ? options[:logger] : Logger.new(STDOUT)
-        @log_level = options.key?(:log_level) ? options[:log_level] : :debug
-        @unique_in_queue_key_base = options.key?(:unique_in_queue_key_base) ? options[:unique_in_queue_key_base] : nil
-
-        # Can be set per each job:
-        @lock_after_execution_period = options.key?(:lock_after_execution_period) ? options[:lock_after_execution_period] : DEFAULT_LOCK_AFTER_EXECUTION_PERIOD
-        @ttl = options.key?(:ttl) ? options[:ttl] : DEFAULT_TTL
-        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?(/in_queue/))
-      end
-
-      def unique_logger
-        logger
+                    :unique_in_queue_key_base
+
+      def initialize
+        debug_mode_from_env
+        @lock_after_execution_period = DEFAULT_LOCK_AFTER_EXECUTION_PERIOD
+        @log_level = DEFAULT_LOG_LEVEL
+        @logger = nil
+        @ttl = DEFAULT_TTL
+        @unique_in_queue_key_base = DEFAULT_UNIQUE_IN_QUEUE_KEY_BASE
+        if @debug_mode
+          # Make sure there is a logger when in debug_mode
+          @logger ||= Logger.new(STDOUT)
+        end
       end
 
-      def unique_log_level
-        log_level
+      def to_hash
+        {
+            debug_mode: debug_mode,
+            lock_after_execution_period: lock_after_execution_period,
+            log_level: log_level,
+            logger: logger,
+            ttl: ttl,
+            unique_in_queue_key_base: unique_in_queue_key_base
+        }
       end
 
-      def log(msg)
-        Resque::UniqueInQueue.in_queue_unique_log(msg, self)
+      def debug_mode=(val)
+        @debug_mode = !!val
       end
 
-      def unique_in_queue_key_base
-        @unique_in_queue_key_base || self.class.unique_in_queue_key_base
-      end
+      private
 
-      def to_hash
-        {
-          logger: logger,
-          log_level: log_level
-        }
+      def debug_mode_from_env
+        env_debug = ENV['RESQUE_DEBUG']
+        @debug_mode = !!(env_debug == 'true' || (env_debug.is_a?(String) && env_debug.match?(/queue/)))
       end
     end
   end

data/lib/resque/unique_in_queue/queue.rb

@@ -64,7 +64,7 @@ module Resque
       end
 
       def cleanup(queue)
-        keys = redis.keys("#{Resque::UniqueInQueue.uniq_config&.unique_in_queue_key_base}:queue:#{queue}:job:*")
+        keys = redis.keys("#{Resque::UniqueInQueue.configuration&.unique_in_queue_key_base}:queue:#{queue}:job:*")
         redis.del(*keys) if keys.any?
       end
 

data/lib/resque/unique_in_queue/version.rb

@@ -2,6 +2,6 @@
 
 module Resque
   module UniqueInQueue
-    VERSION = '1.0.3'.freeze
+    VERSION = '2.0.0'.freeze
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: resque-unique_in_queue
 version: !ruby/object:Gem::Version
-  version: 1.0.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Peter H. Boling
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-10 00:00:00.000000000 Z
+date: 2018-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: colorize