sidekiq-unique-jobs 6.0.25 → 7.0.0.beta2

data/lib/sidekiq_unique_jobs/redis/hash.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Redis
+    #
+    # Class Hash provides convenient access to redis hashes
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class Hash < Entity
+      #
+      # Return entries for this hash
+      #
+      # @param [true,false] with_values false return hash
+      #
+      # @return [Array<Object>] when given with_values: false
+      # @return [Hash<String, String>] when given with_values: true
+      #
+      def entries(with_values: false)
+        if with_values
+          redis { |conn| conn.hgetall(key) }
+        else
+          redis { |conn| conn.hkeys(key) }
+        end
+      end
+
+      #
+      # Removes the key from redis
+      #
+      def del(*fields)
+        redis { |conn| conn.hdel(key, *fields) }
+      end
+
+      #
+      # Get a members value
+      #
+      # @param [String] member the member who's value to get
+      #
+      # @return [Object] whatever is stored on this hash member
+      #
+      def [](member)
+        redis { |conn| conn.hget(key, member) }
+      end
+
+      #
+      # Returns the count for this hash
+      #
+      #
+      # @return [Integer] the length of this hash
+      #
+      def count
+        redis { |conn| conn.hlen(key) }
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/redis/list.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Redis
+    #
+    # Class List provides convenient access to redis hashes
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class List < Entity
+      #
+      # Entries in this list
+      #
+      #
+      # @return [Array<Object>] the elements in this list
+      #
+      def entries
+        redis { |conn| conn.lrange(key, 0, -1) }
+      end
+
+      #
+      # The number of entries in this list
+      #
+      #
+      # @return [Integer] the total number of entries
+      #
+      def count
+        redis { |conn| conn.llen(key) }
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/redis/set.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Redis
+    #
+    # Class Set provides convenient access to redis sets
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class Set < Entity
+      #
+      # Return entries for this set
+      #
+      #
+      # @return [Array<String>]
+      #
+      def entries
+        redis { |conn| conn.smembers(key) }
+      end
+
+      #
+      # Returns the count for this sorted set
+      #
+      #
+      # @return [Integer] the number of entries
+      #
+      def count
+        redis { |conn| conn.scard(key) }
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/redis/sorted_set.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Redis
+    #
+    # Class SortedSet provides convenient access to redis sorted sets
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class SortedSet < Entity
+      #
+      # Return entries for this sorted set
+      #
+      # @param [true,false] with_scores true return
+      #
+      # @return [Array<Object>] when given with_scores: false
+      # @return [Hash] when given with_scores: true
+      #
+      def entries(with_scores: true)
+        entrys = redis { |conn| conn.zrange(key, 0, -1, with_scores: with_scores) }
+        return entrys unless with_scores
+
+        entrys.each_with_object({}) { |pair, hash| hash[pair[0]] = pair[1] }
+      end
+
+      #
+      # Return the zrak of the member
+      #
+      # @param [String] member the member to pull rank on
+      #
+      # @return [Integer]
+      #
+      def rank(member)
+        redis { |conn| conn.zrank(key, member) }
+      end
+
+      #
+      # Return score for a member
+      #
+      # @param [String] member the member for which score
+      #
+      # @return [Integer, Float]
+      #
+      def score(member)
+        redis { |conn| conn.zscore(key, member) }
+      end
+
+      #
+      # Returns the count for this sorted set
+      #
+      #
+      # @return [Integer] the number of entries
+      #
+      def count
+        redis { |conn| conn.zcard(key) }
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/redis/string.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Redis
+    #
+    # Class String provides convenient access to redis strings
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class String < Entity
+      #
+      # Returns the value of the key
+      #
+      #
+      # @return [String]
+      #
+      def value
+        redis { |conn| conn.get(key) }
+      end
+
+      #
+      # Sets the value of the key to given object
+      #
+      # @param [String] obj the object to update the key with
+      #
+      # @return [true, false]
+      #
+      def set(obj)
+        redis { |conn| conn.set(key, obj) }
+      end
+
+      #
+      # Removes the key from redis
+      #
+      def del(*)
+        redis { |conn| conn.del(key) }
+      end
+
+      #
+      # Used only for compatibility with other keys
+      #
+      # @return [1] when key exists
+      # @return [0] when key does not exists
+      def count
+        exist? ? 1 : 0
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/rspec/matchers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module RSpec
+    #
+    # Module Matchers provides RSpec matcher for your workers
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    module Matchers
+    end
+  end
+end
+
+require_relative "matchers/have_valid_sidekiq_options"
+
+RSpec.configure do |config|
+  config.include SidekiqUniqueJobs::RSpec::Matchers
+end

data/lib/sidekiq_unique_jobs/rspec/matchers/have_valid_sidekiq_options.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module RSpec
+    #
+    # Module Matchers provides RSpec matcher for your workers
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    module Matchers
+      #
+      # Class BeLockable validates the unique/lock configuration for your worker.
+      #
+      # @author Mikael Henriksson <mikael@zoolutions.se>
+      #
+      class HaveValidSidekiqOptions
+        attr_reader :worker, :lock_config, :sidekiq_options
+
+        def matches?(worker)
+          @worker          = worker
+          @sidekiq_options = worker.get_sidekiq_options
+          @lock_config     = SidekiqUniqueJobs.validate_worker(sidekiq_options)
+          lock_config.valid?
+        end
+
+        def failure_message
+          <<~FAILURE_MESSAGE
+            Expected #{worker} to have valid sidekiq options but found the following problems:
+            #{lock_config.errors_as_string}
+          FAILURE_MESSAGE
+        end
+
+        def description
+          "have valid sidekiq options"
+        end
+      end
+
+      def have_valid_sidekiq_options(*args) # rubocop:disable Naming/PredicateName
+        HaveValidSidekiqOptions.new(*args)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/{scripts.rb → script.rb}

@@ -1,18 +1,16 @@
 # frozen_string_literal: true
 
-require "pathname"
-require "digest/sha1"
-require "concurrent/map"
-
 module SidekiqUniqueJobs
   # Interface to dealing with .lua files
   #
   # @author Mikael Henriksson <mikael@zoolutions.se>
-  module Scripts
-    LUA_PATHNAME ||= Pathname.new(__FILE__).dirname.join("../../redis").freeze
+  module Script
+    LUA_PATHNAME ||= Pathname.new(__FILE__).dirname.join("lua").freeze
     SCRIPT_SHAS ||= Concurrent::Map.new
 
-    include SidekiqUniqueJobs::Connection
+    extend SidekiqUniqueJobs::Connection
+    extend SidekiqUniqueJobs::Logging
+    extend SidekiqUniqueJobs::Timing
 
     module_function
 
@@ -23,18 +21,22 @@ module SidekiqUniqueJobs
     #   that wasn't previously loaded.
     #
     # @param [Symbol] file_name the name of the lua script
-    # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
-    # @param [Hash] options arguments to pass to the script file
-    # @option options [Array] :keys the array of keys to pass to the script
-    # @option options [Array] :argv the array of arguments to pass to the script
+    # @param [Array<String>] keys script keys
+    # @param [Array<Object>] argv script arguments
+    # @param [Redis] conn the redis connection to use
     #
     # @return value from script
     #
-    def call(file_name, redis_pool, options = {})
-      execute_script(file_name, redis_pool, options)
-    rescue Redis::CommandError => ex
-      handle_error(ex, file_name) do
-        call(file_name, redis_pool, options)
+    def call(file_name, conn, keys: [], argv: [])
+      result, elapsed = timed do
+        execute_script(file_name, conn, keys, argv)
+      end
+
+      log_debug("Executed #{file_name}.lua in #{elapsed}ms")
+      result
+    rescue ::Redis::CommandError => ex
+      handle_error(ex, file_name, conn) do
+        call(file_name, conn, keys: keys, argv: argv)
       end
     end
 
@@ -42,18 +44,18 @@ module SidekiqUniqueJobs
     # Execute the script file
     #
     # @param [Symbol] file_name the name of the lua script
-    # @param [Sidekiq::RedisConnection, ConnectionPool] redis_pool the redis connection
-    # @param [Hash] options arguments to pass to the script file
-    # @option options [Array] :keys the array of keys to pass to the script
-    # @option options [Array] :argv the array of arguments to pass to the script
+    # @param [Redis] conn the redis connection to use
+    # @param [Array] keys the array of keys to pass to the script
+    # @param [Array] argv the array of arguments to pass to the script
     #
     # @return value from script (evalsha)
     #
-    def execute_script(file_name, redis_pool, options = {})
-      redis(redis_pool) do |conn|
-        sha = script_sha(conn, file_name)
-        conn.evalsha(sha, options)
-      end
+    def execute_script(file_name, conn, keys, argv)
+      conn.evalsha(
+        script_sha(conn, file_name),
+        keys,
+        argv,
+      )
     end
 
     #
@@ -80,17 +82,29 @@ module SidekiqUniqueJobs
     #
     # @param [Redis::CommandError] ex exception to handle
     # @param [Symbol] file_name the name of the lua script
+    # @param [Redis] conn the redis connection to use
     #
     # @return [void]
     #
     # @yieldreturn [void] yields back to the caller when NOSCRIPT is raised
-    def handle_error(ex, file_name)
-      if ex.message == "NOSCRIPT No matching script. Please use EVAL."
+    def handle_error(ex, file_name, conn) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      case ex.message
+      when "NOSCRIPT No matching script. Please use EVAL."
         SCRIPT_SHAS.delete(file_name)
         return yield if block_given?
+      when "BUSY Redis is busy running a script. You can only call SCRIPT KILL or SHUTDOWN NOSAVE."
+        begin
+          conn.script(:kill)
+          return yield if block_given?
+        rescue ::Redis::CommandError => ex
+          log_warn(ex)
+          return yield if block_given?
+        end
       end
 
-      raise ScriptError, file_name: file_name, source_exception: ex
+      raise unless ScriptError.intercepts?(ex)
+
+      raise ScriptError.new(ex, script_path(file_name).to_s, script_source(file_name))
     end
 
     #
@@ -101,7 +115,7 @@ module SidekiqUniqueJobs
     # @return [String] the content of the lua file
     #
     def script_source(file_name)
-      script_path(file_name).read
+      Template.new(LUA_PATHNAME).render(script_path(file_name))
     end
 
     #

data/lib/sidekiq_unique_jobs/script/caller.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  # Interface to dealing with .lua files
+  #
+  # @author Mikael Henriksson <mikael@zoolutions.se>
+  module Script
+    #
+    # Module Caller provides the convenience method #call_script
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    module Caller
+      module_function
+
+      # includes "SidekiqUniqueJobs::Connection"
+      # @!parse include SidekiqUniqueJobs::Connection
+      include SidekiqUniqueJobs::Connection
+
+      #
+      # Convenience method to reduce typing,
+      #   calls redis lua scripts.
+      #
+      #
+      # @overload call_script(file_name, keys, argv, conn)
+      #   Call script without options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Array<String>] keys to pass to the the script
+      #   @param [Array<String>] argv arguments to pass to the script
+      #   @param [Redis] conn a redis connection
+      # @overload call_script(file_name, conn, keys:, argv:)
+      #   Call script with options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Redis] conn a redis connection
+      #   @param [Hash] options arguments to pass to the script file
+      #   @option options [Array] :keys to pass to the script
+      #   @option options [Array] :argv arguments to pass to the script
+      #
+      # @return [true,false,String,Integer,Float,nil] returns the return value of the lua script
+      #
+      def call_script(file_name, *args)
+        conn, keys, argv = extract_args(*args)
+        return do_call(file_name, conn, keys, argv) if conn
+
+        pool = defined?(redis_pool) ? redis_pool : nil
+
+        redis(pool) do |new_conn|
+          do_call(file_name, new_conn, keys, argv)
+        end
+      end
+
+      # Only used to reduce a little bit of duplication
+      # @see call_script
+      def do_call(file_name, conn, keys, argv)
+        argv = argv.dup.concat([
+                                 now_f,
+                                 debug_lua,
+                                 max_history,
+                                 file_name,
+                                 redis_version,
+                               ])
+        Script.call(file_name, conn, keys: keys, argv: argv)
+      end
+
+      #
+      # Utility method to allow both symbol keys and arguments
+      #
+      # @overload call_script(file_name, keys, argv, conn)
+      #   Call script without options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Array<String>] keys to pass to the the script
+      #   @param [Array<String>] argv arguments to pass to the script
+      #   @param [Redis] conn a redis connection
+      # @overload call_script(file_name, conn, keys:, argv:)
+      #   Call script with options hash
+      #   @param [Symbol] file_name the name of the file
+      #   @param [Redis] conn a redis connection
+      #   @param [Hash] options arguments to pass to the script file
+      #   @option options [Array] :keys to pass to the script
+      #   @option options [Array] :argv arguments to pass to the script
+      #
+      # @return [Array<Redis, Array, Array>] <description>
+      #
+      def extract_args(*args)
+        options = args.extract_options!
+        if options.length.positive?
+          [args.pop, options.fetch(:keys) { [] }, options.fetch(:argv) { [] }]
+        else
+          keys, argv = args.shift(2)
+          keys ||= []
+          argv ||= []
+          [args.pop, keys, argv]
+        end
+      end
+
+      #
+      # @see SidekiqUniqueJobs#now_f
+      #
+      def now_f
+        SidekiqUniqueJobs.now_f
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#debug_lua
+      #
+      def debug_lua
+        SidekiqUniqueJobs.config.debug_lua
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#max_history
+      #
+      def max_history
+        SidekiqUniqueJobs.config.max_history
+      end
+
+      #
+      # @see SidekiqUniqueJobs::Config#max_history
+      #
+      def redis_version
+        SidekiqUniqueJobs.config.redis_version
+      end
+    end
+  end
+end