Another rewrite

pboling · pboling · commit 936a58e4ca0e · 2018-11-14T20:16:27.000-08:00
diff --git a/README.md b/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
diff --git a/lib/resque-unique_in_queue.rb b/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
diff --git a/lib/resque/plugins/unique_in_queue.rb b/lib/resque/plugins/unique_in_queue.rb
@@ -35,36 +35,40 @@ def redis_key(payload)
           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
diff --git a/lib/resque/unique_in_queue/configuration.rb b/lib/resque/unique_in_queue/configuration.rb
@@ -2,55 +2,53 @@
 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
diff --git a/lib/resque/unique_in_queue/queue.rb b/lib/resque/unique_in_queue/queue.rb
@@ -64,7 +64,7 @@ def destroy(queue, klass, *args)
       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
 
