bullmq 1.58.0 → 1.59.3

package/dist/esm/commands/moveStalledJobsToWait-8.lua

@@ -0,0 +1,112 @@
+--[[
+  Move stalled jobs to wait.
+
+    Input:
+      KEYS[1] 'stalled' (SET)
+      KEYS[2] 'wait',   (LIST)
+      KEYS[3] 'active', (LIST)
+      KEYS[4] 'failed', (ZSET)
+      KEYS[5] 'stalled-check', (KEY)
+
+      KEYS[6] 'meta', (KEY)
+      KEYS[7] 'paused', (LIST)
+
+      KEYS[8] 'event stream' (STREAM)
+
+      ARGV[1]  Max stalled job count
+      ARGV[2]  queue.toKey('')
+      ARGV[3]  timestamp
+      ARGV[4]  max check time
+
+    Events:
+      'stalled' with stalled job id.
+]]
+local rcall = redis.call
+
+local function batches(n, batchSize)
+  local i = 0
+
+  return function()
+    local from = i * batchSize + 1
+    i = i + 1
+    if (from <= n) then
+      local to = math.min(from + batchSize - 1, n)
+      return from, to
+    end
+  end
+end
+
+-- Check if we need to check for stalled jobs now.
+if rcall("EXISTS", KEYS[5]) == 1 then return {{}, {}} end
+
+rcall("SET", KEYS[5], ARGV[3], "PX", ARGV[4])
+
+-- Move all stalled jobs to wait
+local stalling = rcall('SMEMBERS', KEYS[1])
+local stalled = {}
+local failed = {}
+if (#stalling > 0) then
+
+    local dst
+    -- wait or paused destination
+    if rcall("HEXISTS", KEYS[6], "paused") ~= 1 then
+        dst = KEYS[2]
+    else
+        dst = KEYS[7]
+    end
+
+    rcall('DEL', KEYS[1])
+
+    local MAX_STALLED_JOB_COUNT = tonumber(ARGV[1])
+
+    -- Remove from active list
+    for i, jobId in ipairs(stalling) do
+        local jobKey = ARGV[2] .. jobId
+
+        -- Check that the lock is also missing, then we can handle this job as really stalled.
+        if (rcall("EXISTS", jobKey .. ":lock") == 0) then
+            --  Remove from the active queue.
+            local removed = rcall("LREM", KEYS[3], 1, jobId)
+
+            if (removed > 0) then
+                -- If this job has been stalled too many times, such as if it crashes the worker, then fail it.
+                local stalledCount = rcall("HINCRBY", jobKey, "stalledCounter",
+                                           1)
+                if (stalledCount > MAX_STALLED_JOB_COUNT) then
+                    local failedReason = "job stalled more than allowable limit" 
+                    rcall("ZADD", KEYS[4], ARGV[3], jobId)
+                    rcall("HMSET", jobKey, "failedReason",
+                          failedReason, "finishedOn", ARGV[3])
+                    rcall("XADD", KEYS[8], "*", "event", "failed", "jobId",
+                          jobId, 'prev', 'active', 'failedReason',
+                          failedReason)
+                    table.insert(failed, jobId)
+                else
+                    -- Move the job back to the wait queue, to immediately be picked up by a waiting worker.
+                    rcall("RPUSH", dst, jobId)
+                    rcall("XADD", KEYS[8], "*", "event", "waiting", "jobId",
+                          jobId, 'prev', 'active')
+
+                    -- Emit the stalled event
+                    rcall("XADD", KEYS[8], "*", "event", "stalled", "jobId",
+                          jobId)
+                    table.insert(stalled, jobId)
+                end
+            end
+        end
+    end
+end
+
+-- Mark potentially stalled jobs
+local active = rcall('LRANGE', KEYS[3], 0, -1)
+
+if (#active > 0) then
+  for from, to in batches(#active, 7000) do
+    rcall('SADD', KEYS[1], unpack(active, from, to))
+  end
+end
+
+local maxEvents = rcall("HGET", KEYS[6], "opts.maxLenEvents")
+if maxEvents then rcall("XTRIM", KEYS[8], "MAXLEN", "~", maxEvents) end
+
+return {failed, stalled}

package/dist/esm/commands/moveToActive-8.lua

@@ -0,0 +1,100 @@
+--[[
+  Move next job to be processed to active, lock it and fetch its data. The job
+  may be delayed, in that case we need to move it to the delayed set instead.
+
+  This operation guarantees that the worker owns the job during the lock
+  expiration time. The worker is responsible of keeping the lock fresh
+  so that no other worker picks this job again.
+
+  Input:
+      KEYS[1] wait key
+      KEYS[2] active key
+      KEYS[3] priority key
+      KEYS[4] stream events key
+      KEYS[5] stalled key
+
+      -- Rate limiting
+      KEYS[6] rate limiter key
+      KEYS[7] delayed key
+
+      -- Delay events
+      KEYS[8] delay stream key
+
+      -- Arguments
+      ARGV[1] key prefix
+      ARGV[2] lock token
+      ARGV[3] lock duration in milliseconds
+      ARGV[4] timestamp
+      ARGV[5] optional job ID
+
+      ARGV[6] optional jobs per time unit (rate limiter)
+      ARGV[7] optional time unit (rate limiter)
+      ARGV[8] optional rate limit by key
+]]
+
+local jobId
+local rcall = redis.call
+
+if(ARGV[5] ~= "") then
+  jobId = ARGV[5]
+
+  -- clean stalled key
+  rcall("SREM", KEYS[5], jobId)
+else
+  -- no job ID, try non-blocking move from wait to active
+  jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
+end
+
+if jobId then
+  -- Check if we need to perform rate limiting.
+  local maxJobs = tonumber(ARGV[6])
+
+  if(maxJobs) then
+    local rateLimiterKey = KEYS[6];
+
+    if(ARGV[8]) then
+      local groupKey = string.match(jobId, "[^:]+$")
+      if groupKey ~= nil then
+        rateLimiterKey = rateLimiterKey .. ":" .. groupKey
+      end
+    end
+
+    local jobCounter = tonumber(rcall("INCR", rateLimiterKey))
+    -- check if rate limit hit
+    if jobCounter > maxJobs then
+      local exceedingJobs = jobCounter - maxJobs
+      local expireTime = tonumber(rcall("PTTL", rateLimiterKey))
+      local delay = expireTime + ((exceedingJobs - 1) * ARGV[7]) / maxJobs;
+      local timestamp = delay + tonumber(ARGV[4])
+      
+      -- put job into delayed queue
+      rcall("ZADD", KEYS[7], timestamp * 0x1000 + bit.band(jobCounter, 0xfff), jobId);
+      rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", timestamp);
+      rcall("XADD", KEYS[8], "*", "nextTimestamp", timestamp);
+      -- remove from active queue
+      rcall("LREM", KEYS[2], 1, jobId)
+
+      -- Return when we can process more jobs
+      return expireTime
+    else
+      if jobCounter == 1 then
+        rcall("PEXPIRE", rateLimiterKey, ARGV[7])
+      end
+    end
+  end
+
+  local jobKey = ARGV[1] .. jobId
+  local lockKey = jobKey .. ':lock'
+
+  -- get a lock
+  rcall("SET", lockKey, ARGV[2], "PX", ARGV[3])
+  rcall("ZREM", KEYS[3], jobId) -- remove from priority
+
+  rcall("XADD", KEYS[4], "*", "event", "active", "jobId", jobId, "prev", "waiting")
+
+  rcall("HSET", jobKey, "processedOn", ARGV[4])
+
+  return {rcall("HGETALL", jobKey), jobId} -- get job data
+else
+  rcall("XADD", KEYS[4], "*", "event", "drained");
+end

package/dist/esm/commands/moveToDelayed-5.lua

@@ -0,0 +1,45 @@
+--[[
+  Moves job from active to delayed set.
+
+  Input: 
+    KEYS[1] active key
+    KEYS[2] delayed key
+    KEYS[3] job key
+    KEYS[4] events stream
+    KEYS[5] delayed stream
+
+    ARGV[1] delayedTimestamp
+    ARGV[2] the id of the job
+    ARGV[3] queue token
+
+  Output:
+    0 - OK
+   -1 - Missing job.
+   -3 - Job not in active set.
+
+  Events:
+    - delayed key.
+]]
+local rcall = redis.call
+
+if rcall("EXISTS", KEYS[3]) == 1 then
+
+  local jobId = ARGV[2]
+  local score = tonumber(ARGV[1])
+  local delayedTimestamp = (score / 0x1000)
+  
+  local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
+
+  if(numRemovedElements < 1) then
+    return -3
+  end
+
+  rcall("ZADD", KEYS[2], score, jobId)
+
+  rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
+  rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
+
+  return 0
+else
+  return -1
+end

package/dist/esm/commands/moveToFinished-8.lua

@@ -0,0 +1,159 @@
+--[[
+  Move job from active to a finished status (completed o failed)
+  A job can only be moved to completed if it was active.
+  The job must be locked before it can be moved to a finished status,
+  and the lock must be released in this script.
+
+    Input:
+      KEYS[1] active key
+      KEYS[2] completed/failed key
+      KEYS[3] jobId key
+      KEYS[4] wait key
+      KEYS[5] priority key
+      KEYS[6] event stream key
+      KEYS[7] meta key
+      KEYS[8] stalled key
+
+      ARGV[1]  jobId
+      ARGV[2]  timestamp
+      ARGV[3]  msg property
+      ARGV[4]  return value / failed reason
+      ARGV[5]  target (completed/failed)
+      ARGV[6]  shouldRemove
+      ARGV[7]  event data (? maybe just send jobid).
+      ARGV[8]  fetch next?
+      ARGV[9]  keys prefix
+      ARGV[10] lock token
+      ARGV[11] lock duration in milliseconds
+      ARGV[12] parentId
+      ARGV[13] parentQueue
+      ARGV[14] parentKey
+
+    Output:
+      0 OK
+      -1 Missing key.
+      -2 Missing lock.
+      -3 Job not in active set
+      -4 Job has pending dependencies
+
+    Events:
+      'completed/failed'
+]]
+local rcall = redis.call
+
+-- Includes
+--- @include "includes/updateParentDepsIfNeeded"
+--- @include "includes/destructureJobKey"
+
+local jobIdKey = KEYS[3]
+if rcall("EXISTS",jobIdKey) == 1 then -- // Make sure job exists
+
+    if rcall("SCARD", jobIdKey .. ":dependencies") ~= 0 then -- // Make sure it does not have pending dependencies
+      return -4
+    end
+
+    if ARGV[10] ~= "0" then
+      local lockKey = jobIdKey .. ':lock'
+      if rcall("GET", lockKey) == ARGV[10] then
+          rcall("DEL", lockKey)
+          rcall("SREM", KEYS[8], ARGV[1])
+      else
+          return -2
+      end
+    end
+
+    local jobId = ARGV[1]
+
+    -- Remove from active list (if not active we shall return error)
+    local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
+
+    if(numRemovedElements < 1) then
+      return -3
+    end
+
+
+    -- Trim events before emiting them to avoid trimming events emitted in this script
+    local maxEvents = rcall("HGET", KEYS[7], "opts.maxLenEvents")
+    if (maxEvents == false) then
+       maxEvents = 10000
+    end
+    rcall("XTRIM", KEYS[6], "MAXLEN", "~", maxEvents)
+
+    -- If job has a parent we need to
+    -- 1) remove this job id from parents dependencies
+    -- 2) move the job Id to parent "processed" set
+    -- 3) push the results into parent "results" list
+    -- 4) if parent's dependencies is empty, then move parent to "wait/paused". Note it may be a different queue!.
+    -- NOTE: Priorities not supported yet for parent jobs.
+    local parentId = ARGV[12]
+    local parentQueueKey = ARGV[13]
+    if parentId == "" and ARGV[14] ~= "" then
+      parentId = getJobIdFromKey(ARGV[14])
+      parentQueueKey = getJobKeyPrefix(ARGV[14], ":" .. parentId)
+    end
+    if parentId ~= "" and ARGV[5] == "completed" then
+        local parentKey =  parentQueueKey .. ":" .. parentId
+        local dependenciesSet = parentKey .. ":dependencies"
+        local result = rcall("SREM", dependenciesSet, jobIdKey)
+        if result == 1 then
+          updateParentDepsIfNeeded(parentKey, parentQueueKey, dependenciesSet, parentId, jobIdKey, ARGV[4])
+        end
+    end
+
+    -- Remove job?
+    local removeJobs = tonumber(ARGV[6])
+    if removeJobs ~= 1 then
+        -- Add to complete/failed set
+        rcall("ZADD", KEYS[2], ARGV[2], jobId)
+        rcall("HMSET", jobIdKey, ARGV[3], ARGV[4], "finishedOn", ARGV[2]) -- "returnvalue" / "failedReason" and "finishedOn"
+
+        -- Remove old jobs?
+        if removeJobs and removeJobs > 1 then
+            local start = removeJobs - 1
+            local jobIds = rcall("ZREVRANGE", KEYS[2], start, -1)
+            for i, jobId in ipairs(jobIds) do
+                local jobKey = ARGV[9] .. jobId
+                local jobLogKey = jobKey .. ':logs'
+                local jobProcessedKey = jobKey .. ':processed'
+                rcall("DEL", jobKey, jobLogKey, jobProcessedKey)
+            end
+            rcall("ZREMRANGEBYRANK", KEYS[2], 0, -removeJobs)
+        end
+    else
+        local jobLogKey = jobIdKey .. ':logs'
+        local jobProcessedKey = jobIdKey .. ':processed'
+        rcall("DEL", jobIdKey, jobLogKey, jobProcessedKey)
+    end
+
+    rcall("XADD", KEYS[6], "*", "event", ARGV[5], "jobId", jobId, ARGV[3],
+          ARGV[4])
+
+    -- Try to get next job to avoid an extra roundtrip if the queue is not closing,
+    -- and not rate limited.
+    if (ARGV[8] == "1") then
+        -- move from wait to active
+        local jobId = rcall("RPOPLPUSH", KEYS[4], KEYS[1])
+        if jobId then
+            local jobKey = ARGV[9] .. jobId
+            local lockKey = jobKey .. ':lock'
+
+            -- get a lock
+            if ARGV[10] ~= "0" then
+              rcall("SET", lockKey, ARGV[10], "PX", ARGV[11])
+            end
+
+            rcall("ZREM", KEYS[5], jobId) -- remove from priority
+            rcall("XADD", KEYS[6], "*", "event", "active", "jobId", jobId,
+                  "prev", "waiting")
+            rcall("HSET", jobKey, "processedOn", ARGV[2])
+
+            return {rcall("HGETALL", jobKey), jobId} -- get job data
+        else
+          rcall("XADD", KEYS[6], "*", "event", "drained");
+        end
+    end
+
+    return 0
+else
+    return -1
+end

package/dist/esm/commands/moveToWaitingChildren-4.lua

@@ -0,0 +1,60 @@
+--[[
+  Moves job from active to waiting children set.
+
+  Input:
+    KEYS[1] lock key
+    KEYS[2] active key
+    KEYS[3] waitChildrenKey key
+    KEYS[4] job key
+
+    ARGV[1] token
+    ARGV[2] child key
+    ARGV[3] timestamp
+    ARGV[4] the id of the job
+    
+  Output:
+    0 - OK
+    1 - There are not pending dependencies.
+   -1 - Missing job.
+   -2 - Missing lock
+   -3 - Job not in active set
+]]
+local rcall = redis.call
+
+local function move_to_waiting_children (activeKey, waitingChildrenKey, jobId, timestamp)
+  local score = tonumber(timestamp)
+
+  local numRemovedElements = rcall("LREM", activeKey, -1, jobId)
+
+  if(numRemovedElements < 1) then
+    return -3
+  end
+
+  rcall("ZADD", waitingChildrenKey, score, jobId)
+
+  return 0
+end
+
+if ARGV[1] ~= "0" then
+  if rcall("GET", KEYS[1]) ~= ARGV[1] then
+      return -2
+  end
+end
+
+if rcall("EXISTS", KEYS[4]) == 1 then
+  if ARGV[2] ~= "" then
+    if rcall("SISMEMBER", KEYS[4] .. ":dependencies", ARGV[2]) ~= 0 then
+      return move_to_waiting_children(KEYS[2], KEYS[3], ARGV[4], ARGV[3])
+    end
+
+    return 1
+  else
+    if rcall("SCARD", KEYS[4] .. ":dependencies") ~= 0 then 
+      return move_to_waiting_children(KEYS[2], KEYS[3], ARGV[4], ARGV[3])
+    end
+
+    return 1
+  end
+end
+
+return -1

package/dist/esm/commands/obliterate-2.lua

@@ -0,0 +1,129 @@
+--[[
+    Completely obliterates a queue and all of its contents
+     Input:
+
+        KEYS[1] meta
+        KEYS[2] base
+        
+        ARGV[1]  count
+        ARGV[2]  force
+]]
+
+-- This command completely destroys a queue including all of its jobs, current or past 
+-- leaving no trace of its existence. Since this script needs to iterate to find all the job
+-- keys, consider that this call may be slow for very large queues.
+
+-- The queue needs to be "paused" or it will return an error
+-- If the queue has currently active jobs then the script by default will return error,
+-- however this behaviour can be overrided using the `force` option.
+local maxCount = tonumber(ARGV[1])
+local baseKey = KEYS[2]
+
+local rcall = redis.call
+local function getListItems(keyName, max)
+    return rcall('LRANGE', keyName, 0, max - 1)
+end
+
+local function getZSetItems(keyName, max)
+    return rcall('ZRANGE', keyName, 0, max - 1)
+end
+
+local function getSetItems(keyName, max)
+    return rcall('SMEMBERS', keyName, 0, max)
+end
+
+local function removeJobs(keys)
+    for i, key in ipairs(keys) do
+        local jobKey = baseKey .. key 
+        rcall("DEL", jobKey)
+        rcall("DEL", jobKey .. ':logs')
+        rcall("DEL", jobKey .. ':dependencies')
+        rcall("DEL", jobKey .. ':processed')
+    end
+    maxCount = maxCount - #keys
+end
+
+local function removeListJobs(keyName, max)
+    local jobs = getListItems(keyName, max)
+    removeJobs(jobs)
+    rcall("LTRIM", keyName, #jobs, -1)
+end
+
+local function removeZSetJobs(keyName, max)
+    local jobs = getZSetItems(keyName, max)
+    removeJobs(jobs)
+    if(#jobs > 0) then
+        rcall("ZREM", keyName, unpack(jobs))
+    end
+end
+
+local function removeLockKeys(keys)
+    for i, key in ipairs(keys) do
+        rcall("DEL", baseKey .. key .. ':lock')
+    end
+end
+
+-- 1) Check if paused, if not return with error.
+if rcall("HEXISTS", KEYS[1], "paused") ~= 1 then
+    return -1 -- Error, NotPaused
+end
+
+-- 2) Check if there are active jobs, if there are and not "force" return error.
+local activeKey = baseKey .. 'active'
+local activeJobs = getListItems(activeKey, maxCount)
+if (#activeJobs > 0) then
+    if(ARGV[2] == "") then 
+        return -2 -- Error, ExistActiveJobs
+    end
+end
+
+removeLockKeys(activeJobs)
+removeJobs(activeJobs)
+rcall("LTRIM", activeKey, #activeJobs, -1)
+if(maxCount <= 0) then
+    return 1
+end
+
+local waitKey = baseKey .. 'paused'
+removeListJobs(waitKey, maxCount)
+if(maxCount <= 0) then
+    return 1
+end
+
+local delayedKey = baseKey .. 'delayed'
+removeZSetJobs(delayedKey, maxCount)
+if(maxCount <= 0) then
+    return 1
+end
+
+local completedKey = baseKey .. 'completed'
+removeZSetJobs(completedKey, maxCount)
+if(maxCount <= 0) then
+    return 1
+end
+
+local failedKey = baseKey .. 'failed'
+removeZSetJobs(failedKey, maxCount)
+if(maxCount <= 0) then
+    return 1
+end
+
+local waitingChildrenKey = baseKey .. 'waiting-children'
+removeZSetJobs(waitingChildrenKey, maxCount)
+if(maxCount <= 0) then
+    return 1
+end
+
+if(maxCount > 0) then
+    rcall("DEL", baseKey .. 'priority')
+    rcall("DEL", baseKey .. 'events')
+    rcall("DEL", baseKey .. 'delay')
+    rcall("DEL", baseKey .. 'stalled-check')
+    rcall("DEL", baseKey .. 'stalled')
+    rcall("DEL", baseKey .. 'id')
+    rcall("DEL", baseKey .. 'meta')
+    rcall("DEL", baseKey .. 'repeat')
+    return 0
+else
+    return 1
+end

package/dist/esm/commands/pause-4.lua

@@ -0,0 +1,27 @@
+--[[
+  Pauses or resumes a queue globably.
+
+   Input:
+      KEYS[1] 'wait' or 'paused''
+      KEYS[2] 'paused' or 'wait'
+      KEYS[3] 'meta'
+      KEYS[4] events stream key
+
+      ARGV[1] 'paused' or 'resumed'
+
+    Event:
+      publish paused or resumed event.
+]]
+local rcall = redis.call
+
+if rcall("EXISTS", KEYS[1]) == 1 then
+  rcall("RENAME", KEYS[1], KEYS[2])
+end
+
+if ARGV[1] == "paused" then
+  rcall("HSET", KEYS[3], "paused", 1)
+else
+  rcall("HDEL", KEYS[3], "paused")
+end
+
+rcall("XADD", KEYS[4], "*", "event", ARGV[1]);

package/dist/esm/commands/promote-5.lua

@@ -0,0 +1,54 @@
+--[[
+  Promotes a job that is currently "delayed" to the "waiting" state
+
+     Input:
+      KEYS[1] 'delayed'
+      KEYS[2] 'wait'
+      KEYS[3] 'paused'
+      KEYS[4] 'priority'
+      KEYS[5] 'event stream'
+
+      ARGV[1]  queue.toKey('')
+      ARGV[2]  jobId
+
+     Events:
+      'waiting'
+]]
+local rcall = redis.call;
+local jobId = ARGV[2]
+
+if redis.call("ZREM", KEYS[1], jobId) == 1 then
+  local priority = tonumber(rcall("HGET", ARGV[1] .. jobId, "priority")) or 0
+
+  local target = KEYS[2];
+
+  if rcall("EXISTS", KEYS[3]) == 1 then
+    target = KEYS[3]
+  end
+
+  if priority == 0 then
+    -- LIFO or FIFO
+    rcall("LPUSH", target, jobId)
+  else
+    -- Priority add
+    rcall("ZADD", KEYS[4], priority, jobId)
+    local count = rcall("ZCOUNT", KEYS[4], 0, priority)
+
+    local len = rcall("LLEN", target)
+    local id = rcall("LINDEX", target, len - (count - 1))
+    if id then
+      rcall("LINSERT", target, "BEFORE", id, jobId)
+    else
+      rcall("RPUSH", target, jobId)
+    end
+  end
+
+  -- Emit waiting event (wait..ing@token)
+  rcall("XADD", KEYS[5], "*", "event", "waiting", "jobId", jobId, "prev", "delayed");
+
+  rcall("HSET", ARGV[1] .. jobId, "delay", 0)
+
+  return 0
+else
+  return -3
+end