sidekiq-unique-jobs 6.0.23 → 7.1.12

data/lib/sidekiq_unique_jobs/lua/reap_orphans.lua

@@ -0,0 +1,94 @@
+redis.replicate_commands()
+
+-------- BEGIN keys ---------
+local digests_set  = KEYS[1]
+local schedule_set = KEYS[2]
+local retry_set    = KEYS[3]
+--------  END keys  ---------
+
+-------- BEGIN argv ---------
+local reaper_count = tonumber(ARGV[1])
+local threshold    = tonumber(ARGV[2])
+--------  END argv  ---------
+
+--------  BEGIN injected arguments --------
+local current_time = tonumber(ARGV[3])
+local debug_lua    = ARGV[4] == "true"
+local max_history  = tonumber(ARGV[5])
+local script_name  = ARGV[6] .. ".lua"
+local redisversion = ARGV[7]
+---------  END injected arguments ---------
+
+
+--------  BEGIN local functions --------
+<%= include_partial "shared/_common.lua" %>
+<%= include_partial "shared/_find_digest_in_queues.lua" %>
+<%= include_partial "shared/_find_digest_in_sorted_set.lua" %>
+<%= include_partial "shared/_find_digest_in_process_set.lua" %>
+----------  END local functions ----------
+
+
+--------  BEGIN delete_orphaned.lua --------
+log_debug("BEGIN")
+local found     = false
+local per       = 50
+local total     = redis.call("ZCARD", digests_set)
+local index     = 0
+local del_count = 0
+local redis_ver = toversion(redisversion)
+local del_cmd   = "DEL"
+
+if tonumber(redis_ver["major"]) >= 4 then del_cmd = "UNLINK"; end
+
+repeat
+  log_debug("Interating through:", digests_set, "for orphaned locks")
+  local digests  = redis.call("ZREVRANGE", digests_set, index, index + per -1)
+
+  for _, digest in pairs(digests) do
+    log_debug("Searching for digest:", digest, "in", schedule_set)
+    found = find_digest_in_sorted_set(schedule_set, digest)
+
+    if found ~= true then
+      log_debug("Searching for digest:", digest, "in", retry_set)
+      found = find_digest_in_sorted_set(retry_set, digest)
+    end
+
+    if found ~= true then
+      log_debug("Searching for digest:", digest, "in all queues")
+      local queue = find_digest_in_queues(digest)
+
+      if queue then
+        log_debug("found digest:", digest, "in queue:", queue)
+        found = true
+      end
+    end
+
+    -- TODO: Add check for jobs checked out by process
+    if found ~= true then
+      log_debug("Searching for digest:", digest, "in process sets")
+      found = find_digest_in_process_set(digest, threshold)
+    end
+
+    if found ~= true then
+      local queued     = digest .. ":QUEUED"
+      local primed     = digest .. ":PRIMED"
+      local locked     = digest .. ":LOCKED"
+      local info       = digest .. ":INFO"
+      local run_digest = digest .. ":RUN"
+      local run_queued = digest .. ":RUN:QUEUED"
+      local run_primed = digest .. ":RUN:PRIMED"
+      local run_locked = digest .. ":RUN:LOCKED"
+      local run_info   = digest .. ":RUN:INFO"
+
+      redis.call(del_cmd, digest, queued, primed, locked, info, run_digest, run_queued, run_primed, run_locked, run_info)
+
+      redis.call("ZREM", digests_set, digest)
+      del_count = del_count + 1
+    end
+  end
+
+  index = index + per
+until index >= total or del_count >= reaper_count
+
+log_debug("END")
+return del_count

data/lib/sidekiq_unique_jobs/lua/shared/_common.lua

@@ -0,0 +1,40 @@
+local function toversion(version)
+  local _, _, maj, min, pat = string.find(version, "(%d+)%.(%d+)%.(%d+)")
+
+  return {
+    ["version"] = version,
+    ["major"]   = tonumber(maj),
+    ["minor"]   = tonumber(min),
+    ["patch"]   = tonumber(pat)
+  }
+end
+
+local function toboolean(val)
+  val = tostring(val)
+  return val == "1" or val == "true"
+end
+
+local function log_debug( ... )
+  if debug_lua ~= true then return end
+
+  local result = ""
+  for _,v in ipairs(arg) do
+    result = result .. " " .. tostring(v)
+  end
+  redis.log(redis.LOG_DEBUG, script_name .. " -" ..  result)
+end
+
+local function log(message, prev_jid)
+  if not max_history or max_history == 0 then return end
+  local entry = cjson.encode({digest = digest, job_id = job_id, script = script_name, message = message, time = current_time, prev_jid = prev_jid })
+
+  log_debug("ZADD", changelog, current_time, entry);
+  redis.call("ZADD", changelog, current_time, entry);
+  local total_entries = redis.call("ZCARD", changelog)
+  local removed_entries = redis.call("ZREMRANGEBYRANK", changelog, max_history, -1)
+  if removed_entries > 0 then
+    log_debug("Removing", removed_entries , "entries from changelog (total entries", total_entries, "exceeds max_history:", max_history ..")");
+  end
+  log_debug("PUBLISH", changelog, entry);
+  redis.call("PUBLISH", changelog, entry);
+end

data/lib/sidekiq_unique_jobs/lua/shared/_current_time.lua

@@ -0,0 +1,8 @@
+local function current_time()
+  local time = redis.call("time")
+  local s = time[1]
+  local ms = time[2]
+  local number = tonumber((s .. "." .. ms))
+
+  return number
+end

data/lib/sidekiq_unique_jobs/lua/shared/_delete_from_queue.lua

@@ -0,0 +1,22 @@
+local function delete_from_queue(queue, digest)
+  local per    = 50
+  local total  = redis.call("LLEN", queue)
+  local index  = 0
+  local result = nil
+
+  while (index < total) do
+    local items = redis.call("LRANGE", queue, index, index + per -1)
+    if #items == 0 then
+      break
+    end
+    for _, item in pairs(items) do
+      if string.find(item, digest) then
+        redis.call("LREM", queue, 1, item)
+        result = item
+        break
+      end
+    end
+    index = index + per
+  end
+  return result
+end

data/lib/sidekiq_unique_jobs/lua/shared/_delete_from_sorted_set.lua

@@ -0,0 +1,18 @@
+local function delete_from_sorted_set(name, digest)
+  local per   = 50
+  local total = redis.call("zcard", name)
+  local index = 0
+  local result
+  while (index < total) do
+    local items = redis.call("ZRANGE", name, index, index + per -1)
+    for _, item in pairs(items) do
+      if string.find(item, digest) then
+        redis.call("ZREM", name, item)
+        result = item
+        break
+      end
+    end
+    index = index + per
+  end
+  return result
+end

data/lib/sidekiq_unique_jobs/lua/shared/_find_digest_in_process_set.lua

@@ -0,0 +1,53 @@
+local function find_digest_in_process_set(digest, threshold)
+  local process_cursor = 0
+  local job_cursor     = 0
+  local pattern        = "*" .. digest .. "*"
+  local found          = false
+
+  log_debug("Searching in process list",
+            "for digest:", digest,
+            "cursor:", process_cursor)
+
+  repeat
+    local process_paginator   = redis.call("SSCAN", "processes", process_cursor, "MATCH", "*")
+    local next_process_cursor = process_paginator[1]
+    local processes           = process_paginator[2]
+    log_debug("Found number of processes:", #processes, "next cursor:", next_process_cursor)
+
+    for _, process in ipairs(processes) do
+      local workers_key = process .. ":workers"
+      log_debug("searching in process set:", process,
+                "for digest:", digest,
+                "cursor:", process_cursor)
+
+      local jobs = redis.call("HGETALL", workers_key)
+
+      if #jobs == 0 then
+        log_debug("No entries in:", workers_key)
+      else
+        for i = 1, #jobs, 2 do
+          local jobstr = jobs[i +1]
+          if string.find(string.gsub(jobstr, ':RUN', ''), string.gsub(digest, ':RUN', '')) then
+            log_debug("Found digest", digest, "in:", workers_key)
+            found = true
+            break
+          end
+
+          local job = cjson.decode(jobstr)
+          if job.payload.created_at > threshold then
+            found = true
+            break
+          end
+        end
+      end
+
+      if found == true then
+        break
+      end
+    end
+
+    process_cursor = next_process_cursor
+  until found == true or process_cursor == "0"
+
+  return found
+end

data/lib/sidekiq_unique_jobs/lua/shared/_find_digest_in_queues.lua

@@ -0,0 +1,43 @@
+local function find_digest_in_queues(digest)
+  local cursor = "0"
+  local count  = 50
+  local result = nil
+  local found  = false
+
+  repeat
+    log_debug("searching all queues for a matching digest:", digest)
+    local pagination  = redis.call("SCAN", cursor, "MATCH", "queue:*", "COUNT", count)
+    local next_cursor = pagination[1]
+    local queues      = pagination[2]
+
+    for _, queue in ipairs(queues) do
+      local per    = 50
+      local total  = redis.call("LLEN", queue)
+      local index  = 0
+
+      log_debug("searching in:", queue,
+                "for digest:", digest,
+                "from:", index,
+                "to:", total,
+                "(per: " .. per .. ")",
+                "cursor:", cursor)
+
+      while (index < total) do
+        local items = redis.call("LRANGE", queue, index, index + per -1)
+        for _, item in pairs(items) do
+          if string.find(item, digest) then
+            log_debug("Found digest:", digest, "in queue:", queue)
+            result = cjson.decode(item).queue
+            found = true
+            break
+          end
+        end
+        index = index + per
+      end
+    end
+
+    cursor = next_cursor
+  until found == true or cursor == "0"
+
+  return result
+end

data/lib/sidekiq_unique_jobs/lua/shared/_find_digest_in_sorted_set.lua

@@ -0,0 +1,24 @@
+local function find_digest_in_sorted_set(name, digest)
+  local cursor  = 0
+  local count   = 5
+  local pattern = "*" .. digest .. "*"
+  local found   = false
+
+  log_debug("searching in:", name,
+            "for digest:", digest,
+            "cursor:", cursor)
+  repeat
+    local pagination  = redis.call("ZSCAN", name, cursor, "MATCH", pattern, "COUNT", count)
+    local next_cursor = pagination[1]
+    local items       = pagination[2]
+
+    if #items > 0 then
+      log_debug("Found digest", digest, "in zset:", name)
+      found = true
+    end
+
+    cursor = next_cursor
+  until found == true or cursor == "0"
+
+  return found
+end

data/lib/sidekiq_unique_jobs/lua/shared/_hgetall.lua

@@ -0,0 +1,13 @@
+local hgetall = function (key)
+  local bulk = redis.call("HGETALL", key)
+  local result = {}
+  local nextkey
+  for i, v in ipairs(bulk) do
+    if i % 2 == 1 then
+      nextkey = v
+    else
+      result[nextkey] = v
+    end
+  end
+  return result
+end

data/lib/sidekiq_unique_jobs/lua/shared/_upgrades.lua

@@ -0,0 +1,3 @@
+local function upgrade_v6_to_v7()
+
+end

data/lib/sidekiq_unique_jobs/lua/unlock.lua

@@ -0,0 +1,102 @@
+-------- BEGIN keys ---------
+local digest    = KEYS[1]
+local queued    = KEYS[2]
+local primed    = KEYS[3]
+local locked    = KEYS[4]
+local info      = KEYS[5]
+local changelog = KEYS[6]
+local digests   = KEYS[7]
+-------- END keys ---------
+
+
+-------- BEGIN lock arguments ---------
+local job_id    = ARGV[1]
+local pttl      = tonumber(ARGV[2])
+local lock_type = ARGV[3]
+local limit     = tonumber(ARGV[4])
+-------- END lock arguments -----------
+
+
+--------  BEGIN injected arguments --------
+local current_time = tonumber(ARGV[5])
+local debug_lua    = ARGV[6] == "true"
+local max_history  = tonumber(ARGV[7])
+local script_name  = tostring(ARGV[8]) .. ".lua"
+local redisversion = ARGV[9]
+---------  END injected arguments ---------
+
+
+--------  BEGIN Variables --------
+local queued_count = redis.call("LLEN", queued)
+local primed_count = redis.call("LLEN", primed)
+local locked_count = redis.call("HLEN", locked)
+---------  END Variables ---------
+
+
+--------  BEGIN local functions --------
+<%= include_partial "shared/_common.lua" %>
+----------  END local functions ----------
+
+
+---------  Begin unlock.lua ---------
+log_debug("BEGIN unlock digest:", digest, "(job_id: " .. job_id ..")")
+
+log_debug("HEXISTS", locked, job_id)
+if redis.call("HEXISTS", locked, job_id) == 0 then
+  -- TODO: Improve orphaned lock detection
+  if queued_count == 0 and primed_count == 0 and locked_count == 0 then
+    log_debug("Orphaned lock")
+  else
+    local result = ""
+    for i,v in ipairs(redis.call("HKEYS", locked)) do
+      result = result .. v .. ","
+    end
+    result = locked .. " (" .. result .. ")"
+    log("Yielding to: " .. result)
+    log_debug("Yielding to", result, locked, "by job", job_id)
+    return nil
+  end
+end
+
+-- Just in case something went wrong
+log_debug("LREM", queued, -1, job_id)
+redis.call("LREM", queued, -1, job_id)
+
+log_debug("LREM", primed, -1, job_id)
+redis.call("LREM", primed, -1, job_id)
+
+local redis_version = toversion(redisversion)
+local del_cmd       = "DEL"
+
+if tonumber(redis_version["major"]) >= 4 then del_cmd =  "UNLINK"; end
+
+if lock_type ~= "until_expired" then
+  log_debug(del_cmd, digest, info)
+  redis.call(del_cmd, digest, info)
+
+  log_debug("HDEL", locked, job_id)
+  redis.call("HDEL", locked, job_id)
+end
+
+local locked_count = redis.call("HLEN", locked)
+
+if locked_count and locked_count < 1 then
+  log_debug(del_cmd, locked)
+  redis.call(del_cmd, locked)
+end
+
+if limit and limit <= 1 and locked_count and locked_count <= 1 then
+  log_debug("ZREM", digests, digest)
+  redis.call("ZREM", digests, digest)
+end
+
+log_debug("LPUSH", queued, "1")
+redis.call("LPUSH", queued, "1")
+
+log_debug("PEXPIRE", queued, 5000)
+redis.call("PEXPIRE", queued, 5000)
+
+log("Unlocked")
+log_debug("END unlock digest:", digest, "(job_id: " .. job_id ..")")
+return job_id
+---------  END unlock.lua ---------

data/lib/sidekiq_unique_jobs/lua/update_version.lua

@@ -0,0 +1,40 @@
+-------- BEGIN keys ---------
+local live_key = KEYS[1]
+local dead_key = KEYS[2]
+-------- END keys ---------
+
+-------- BEGIN lock arguments ---------
+local version  = ARGV[1]
+-------- END lock arguments -----------
+
+--------  BEGIN injected arguments --------
+local current_time = tonumber(ARGV[2])
+local debug_lua    = ARGV[3] == "true"
+local max_history  = tonumber(ARGV[4])
+local script_name  = tostring(ARGV[5]) .. ".lua"
+---------  END injected arguments ---------
+
+--------  BEGIN local functions --------
+<%= include_partial "shared/_common.lua" %>
+----------  END local functions ----------
+
+
+--------  BEGIN set_version.lua --------
+log_debug("BEGIN setting version:", version)
+
+local updated     = false
+local old_version = redis.call("GETSET", live_key, version)
+
+if not old_version then
+  log_debug("No previous version found")
+  updated = true
+elseif old_version ~= version then
+  log_debug("Old version:", old_version, "differs from:", version)
+  redis.call("SET", dead_key, old_version)
+  updated = true
+end
+
+return updated
+--------  END delete.lua --------
+
+

data/lib/sidekiq_unique_jobs/lua/upgrade.lua

@@ -0,0 +1,68 @@
+redis.replicate_commands()
+-------- BEGIN keys ---------
+local live_version = KEYS[1]
+local dead_version = KEYS[2]
+-------- END keys ---------
+
+--------  BEGIN injected arguments --------
+local current_time = tonumber(ARGV[5])
+local debug_lua    = ARGV[6] == "true"
+local max_history  = tonumber(ARGV[7])
+local script_name  = tostring(ARGV[8]) .. ".lua"
+local redisversion = ARGV[9]
+---------  END injected arguments ---------
+
+--------  BEGIN local functions --------
+<%= include_partial "shared/_common.lua" %>
+<%= include_partial "shared/_upgrades.lua" %>
+----------  END local functions ----------
+
+
+local new_version   = redis.call("GET", live_version)
+local old_version   = redis.call("GET", dead_version)
+local redis_version = toversion(redisversion)
+local upgraded      = 0
+local del_cmd       = "DEL"
+
+if redis_version["major"] >= 4 then del_cmd = "UNLINK"; end
+--------  BEGIN delete.lua --------
+
+log_debug("BEGIN upgrading from: ", old_version, "to:", new_version)
+
+-- 1. Loop through all uniquejobs:jajshdahdas:GRABBED
+local cursor = "0"
+local per   = 50
+repeat
+  local pagination   = redis.call("SCAN", cursor, "MATCH", "*:GRABBED", "COUNT", per)
+  local next_cursor  = pagination[1]
+  local grabbed_keys = pagination[2]
+
+  for _, grabbed in ipairs(grabbed_keys) do
+    local locked_key = grabbed.gsub(":GRABBED", ":LOCKED")
+    local locks      = redis.call("HGETALL", grabbed)
+
+    if #locks == 0 then
+      log_debug("No entries in:", grabbed)
+    else
+      log_debug("HMSET", locked_key, unpack(locks))
+      redis.call("HMSET", locked_key, unpack(locks))
+    end
+
+    log_debug("DEL", grabbed)
+    redis.call("DEL", grabbed)
+
+    upgraded = upgraded + 1
+  end
+
+  cursor = next_cursor
+  if cursor == "0" then
+    log_debug("Looped through all grabbed keys, stopping iteration")
+  end
+until cursor == "0"
+
+
+
+log_debug("END upgrading from: ", old_version, "to:", new_version)
+
+return
+--------  END delete.lua --------

data/lib/sidekiq_unique_jobs/middleware/client.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Middleware
+    # The unique sidekiq middleware for the client push
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Client
+      # prepend "SidekiqUniqueJobs::Middleware"
+      # @!parse prepends SidekiqUniqueJobs::Middleware
+      prepend SidekiqUniqueJobs::Middleware
+      # includes "SidekiqUniqueJobs::Reflectable"
+      # @!parse include SidekiqUniqueJobs::Reflectable
+      include SidekiqUniqueJobs::Reflectable
+
+      # Calls this client middleware
+      #   Used from Sidekiq.process_single
+      #
+      # @see SidekiqUniqueJobs::Middleware#call
+      #
+      # @see https://github.com/mperham/sidekiq/wiki/Job-Format
+      # @see https://github.com/mperham/sidekiq/wiki/Middleware
+      #
+      # @yield when uniqueness is disable
+      # @yield when the lock is successful
+      def call(*, &block)
+        lock(&block)
+      end
+
+      private
+
+      def lock
+        lock_instance.lock do
+          reflect(:locked, item)
+          return yield
+        end
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/middleware/server.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module SidekiqUniqueJobs
+  module Middleware
+    # The unique sidekiq middleware for the server processor
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Server
+      # prepend "SidekiqUniqueJobs::Middleware"
+      # @!parse prepends SidekiqUniqueJobs::Middleware
+      prepend SidekiqUniqueJobs::Middleware
+
+      #
+      #
+      # Runs the server middleware (used from Sidekiq::Processor#process)
+      #
+      # @see SidekiqUniqueJobs::Middleware#call
+      #
+      # @see https://github.com/mperham/sidekiq/wiki/Job-Format
+      # @see https://github.com/mperham/sidekiq/wiki/Middleware
+      #
+      # @yield when uniqueness is disabled
+      # @yield when owning the lock
+      def call(*, &block)
+        lock_instance.execute(&block)
+      end
+    end
+  end
+end

data/lib/sidekiq_unique_jobs/middleware.rb

@@ -1,47 +1,45 @@
 # frozen_string_literal: true
 
-require "sidekiq"
-
 module SidekiqUniqueJobs
   #
   # Provides the sidekiq middleware that makes the gem work
   #
-  # @author Mikael Henriksson <mikael@zoolutions.se>
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
   #
   module Middleware
-    def self.extended(base)
-      base.class_eval do
-        configure_middleware
-      end
-    end
+    include SidekiqUniqueJobs::Logging::Middleware
+    include SidekiqUniqueJobs::OptionsWithFallback
+    include SidekiqUniqueJobs::JSON
 
-    def configure_middleware
-      configure_server_middleware
-      configure_client_middleware
-    end
+    # The sidekiq job hash
+    # @return [Hash] the Sidekiq job hash
+    attr_reader :item
 
-    def configure_server_middleware
-      Sidekiq.configure_server do |config|
-        config.client_middleware do |chain|
-          require "sidekiq_unique_jobs/client/middleware"
-          chain.add SidekiqUniqueJobs::Client::Middleware
-        end
+    #
+    # This method runs before (prepended) the actual middleware implementation.
+    #   This is done to reduce duplication
+    #
+    # @param [Sidekiq::Worker] worker_class
+    # @param [Hash] item a sidekiq job hash
+    # @param [String] queue name of the queue
+    # @param [ConnectionPool] redis_pool only used for compatility reasons
+    #
+    # @return [yield<super>] <description>
+    #
+    # @yieldparam [<type>] if <description>
+    # @yieldreturn [<type>] <describe what yield should return>
+    def call(worker_class, item, queue, redis_pool = nil)
+      @worker_class = worker_class
+      @item         = item
+      @queue        = queue
+      @redis_pool   = redis_pool
+      return yield if unique_disabled?
 
-        config.server_middleware do |chain|
-          require "sidekiq_unique_jobs/server/middleware"
-          chain.add SidekiqUniqueJobs::Server::Middleware
-        end
-      end
-    end
+      SidekiqUniqueJobs::Job.prepare(item) unless item[LOCK_DIGEST]
 
-    def configure_client_middleware
-      Sidekiq.configure_client do |config|
-        config.client_middleware do |chain|
-          require "sidekiq_unique_jobs/client/middleware"
-          chain.add SidekiqUniqueJobs::Client::Middleware
-        end
+      with_logging_context do
+        super
       end
     end
   end
 end
-SidekiqUniqueJobs.extend SidekiqUniqueJobs::Middleware