bullmq 3.0.0 → 3.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (50) hide show
  1. package/README.md +1 -1
  2. package/dist/cjs/classes/scripts.d.ts +2 -2
  3. package/dist/cjs/classes/scripts.js +36 -6
  4. package/dist/cjs/classes/scripts.js.map +1 -1
  5. package/dist/cjs/commands/moveToDelayed-8.lua +63 -0
  6. package/dist/cjs/commands/moveToFinished-12.lua +23 -12
  7. package/dist/{esm/commands/retryJob-6.lua → cjs/commands/retryJob-8.lua} +15 -8
  8. package/dist/cjs/enums/error-code.enum.d.ts +2 -1
  9. package/dist/cjs/enums/error-code.enum.js +1 -0
  10. package/dist/cjs/enums/error-code.enum.js.map +1 -1
  11. package/dist/cjs/scripts/index.d.ts +2 -2
  12. package/dist/cjs/scripts/index.js +2 -2
  13. package/dist/cjs/scripts/{moveToDelayed-5.d.ts → moveToDelayed-8.d.ts} +0 -0
  14. package/dist/cjs/scripts/moveToDelayed-8.js +116 -0
  15. package/dist/cjs/scripts/moveToDelayed-8.js.map +1 -0
  16. package/dist/cjs/scripts/moveToFinished-12.js +23 -12
  17. package/dist/cjs/scripts/moveToFinished-12.js.map +1 -1
  18. package/dist/cjs/scripts/{retryJob-6.d.ts → retryJob-8.d.ts} +0 -0
  19. package/dist/cjs/scripts/retryJob-8.js +112 -0
  20. package/dist/cjs/scripts/retryJob-8.js.map +1 -0
  21. package/dist/esm/classes/scripts.d.ts +2 -2
  22. package/dist/esm/classes/scripts.js +36 -6
  23. package/dist/esm/classes/scripts.js.map +1 -1
  24. package/dist/esm/commands/moveToDelayed-8.lua +63 -0
  25. package/dist/esm/commands/moveToFinished-12.lua +23 -12
  26. package/dist/{cjs/commands/retryJob-6.lua → esm/commands/retryJob-8.lua} +15 -8
  27. package/dist/esm/enums/error-code.enum.d.ts +2 -1
  28. package/dist/esm/enums/error-code.enum.js +1 -0
  29. package/dist/esm/enums/error-code.enum.js.map +1 -1
  30. package/dist/esm/scripts/index.d.ts +2 -2
  31. package/dist/esm/scripts/index.js +2 -2
  32. package/dist/esm/scripts/{moveToDelayed-5.d.ts → moveToDelayed-8.d.ts} +0 -0
  33. package/dist/esm/scripts/moveToDelayed-8.js +113 -0
  34. package/dist/esm/scripts/moveToDelayed-8.js.map +1 -0
  35. package/dist/esm/scripts/moveToFinished-12.js +23 -12
  36. package/dist/esm/scripts/moveToFinished-12.js.map +1 -1
  37. package/dist/esm/scripts/{retryJob-6.d.ts → retryJob-8.d.ts} +0 -0
  38. package/dist/esm/scripts/retryJob-8.js +109 -0
  39. package/dist/esm/scripts/retryJob-8.js.map +1 -0
  40. package/package.json +1 -1
  41. package/dist/cjs/commands/moveToDelayed-5.lua +0 -54
  42. package/dist/cjs/scripts/moveToDelayed-5.js +0 -52
  43. package/dist/cjs/scripts/moveToDelayed-5.js.map +0 -1
  44. package/dist/cjs/scripts/retryJob-6.js +0 -60
  45. package/dist/cjs/scripts/retryJob-6.js.map +0 -1
  46. package/dist/esm/commands/moveToDelayed-5.lua +0 -54
  47. package/dist/esm/scripts/moveToDelayed-5.js +0 -49
  48. package/dist/esm/scripts/moveToDelayed-5.js.map +0 -1
  49. package/dist/esm/scripts/retryJob-6.js +0 -57
  50. package/dist/esm/scripts/retryJob-6.js.map +0 -1
@@ -0,0 +1,113 @@
1
+ const content = `--[[
2
+ Moves job from active to delayed set.
3
+ Input:
4
+ KEYS[1] wait key
5
+ KEYS[2] active key
6
+ KEYS[3] priority key
7
+ KEYS[4] delayed key
8
+ KEYS[5] job key
9
+ KEYS[6] events stream
10
+ KEYS[7] paused key
11
+ KEYS[8] meta key
12
+ ARGV[1] key prefix
13
+ ARGV[2] timestamp
14
+ ARGV[3] delayedTimestamp
15
+ ARGV[4] the id of the job
16
+ ARGV[5] queue token
17
+ Output:
18
+ 0 - OK
19
+ -1 - Missing job.
20
+ -3 - Job not in active set.
21
+ Events:
22
+ - delayed key.
23
+ ]]
24
+ local rcall = redis.call
25
+ -- Includes
26
+ --[[
27
+ Updates the delay set, by moving delayed jobs that should
28
+ be processed now to "wait".
29
+ Events:
30
+ 'waiting'
31
+ ]]
32
+ local rcall = redis.call
33
+ -- Includes
34
+ --[[
35
+ Function to add job considering priority.
36
+ ]]
37
+ local function addJobWithPriority(priorityKey, priority, targetKey, jobId)
38
+ rcall("ZADD", priorityKey, priority, jobId)
39
+ local count = rcall("ZCOUNT", priorityKey, 0, priority)
40
+ local len = rcall("LLEN", targetKey)
41
+ local id = rcall("LINDEX", targetKey, len - (count - 1))
42
+ if id then
43
+ rcall("LINSERT", targetKey, "BEFORE", id, jobId)
44
+ else
45
+ rcall("RPUSH", targetKey, jobId)
46
+ end
47
+ end
48
+ --[[
49
+ Function to check for the meta.paused key to decide if we are paused or not
50
+ (since an empty list and !EXISTS are not really the same).
51
+ ]]
52
+ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
53
+ if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
54
+ return waitKey
55
+ else
56
+ return pausedKey
57
+ end
58
+ end
59
+ -- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
60
+ -- there are more delayed jobs to process.
61
+ local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
62
+ metaKey, eventStreamKey, prefix, timestamp)
63
+ local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
64
+ if (#jobs > 0) then
65
+ rcall("ZREM", delayedKey, unpack(jobs))
66
+ -- check if we need to use push in paused instead of waiting
67
+ local target = getTargetQueueList(metaKey, waitKey, pausedKey)
68
+ for _, jobId in ipairs(jobs) do
69
+ local priority =
70
+ tonumber(rcall("HGET", prefix .. jobId, "priority")) or 0
71
+ if priority == 0 then
72
+ -- LIFO or FIFO
73
+ rcall("LPUSH", target, jobId)
74
+ else
75
+ addJobWithPriority(priorityKey, priority, target, jobId)
76
+ end
77
+ -- Emit waiting event
78
+ rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
79
+ jobId, "prev", "delayed")
80
+ rcall("HSET", prefix .. jobId, "delay", 0)
81
+ end
82
+ end
83
+ end
84
+ promoteDelayedJobs(KEYS[4], KEYS[1], KEYS[3], KEYS[7], KEYS[8], KEYS[6], ARGV[1], ARGV[2])
85
+ if rcall("EXISTS", KEYS[5]) == 1 then
86
+ if ARGV[5] ~= "0" then
87
+ local lockKey = KEYS[5] .. ':lock'
88
+ if rcall("GET", lockKey) == ARGV[5] then
89
+ rcall("DEL", lockKey)
90
+ else
91
+ return -2
92
+ end
93
+ end
94
+ local jobId = ARGV[4]
95
+ local score = tonumber(ARGV[3])
96
+ local delayedTimestamp = (score / 0x1000)
97
+ local numRemovedElements = rcall("LREM", KEYS[2], -1, jobId)
98
+ if(numRemovedElements < 1) then
99
+ return -3
100
+ end
101
+ rcall("ZADD", KEYS[4], score, jobId)
102
+ rcall("XADD", KEYS[6], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
103
+ return 0
104
+ else
105
+ return -1
106
+ end
107
+ `;
108
+ export const moveToDelayed = {
109
+ name: 'moveToDelayed',
110
+ content,
111
+ keys: 8,
112
+ };
113
+ //# sourceMappingURL=moveToDelayed-8.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"moveToDelayed-8.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Gf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
@@ -41,6 +41,7 @@ const content = `--[[
41
41
  -2 Missing lock.
42
42
  -3 Job not in active set
43
43
  -4 Job has pending dependencies
44
+ -6 Lock is not owned by this client
44
45
  Events:
45
46
  'completed/failed'
46
47
  ]]
@@ -424,11 +425,19 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
424
425
  local maxAge = opts['keepJobs']['age']
425
426
  if token ~= "0" then
426
427
  local lockKey = jobIdKey .. ':lock'
427
- if rcall("GET", lockKey) == token then
428
+ local lockToken = rcall("GET", lockKey)
429
+ if lockToken == token then
428
430
  rcall("DEL", lockKey)
429
431
  rcall("SREM", KEYS[5], ARGV[1])
430
432
  else
431
- return -2
433
+ if lockToken then
434
+ rcall("SET", "DEBUG", lockToken)
435
+ -- Lock exists but token does not match
436
+ return -6
437
+ else
438
+ -- Lock is missing completely
439
+ return -2
440
+ end
432
441
  end
433
442
  end
434
443
  if rcall("SCARD", jobIdKey .. ":dependencies") ~= 0 then -- // Make sure it does not have pending dependencies
@@ -454,11 +463,13 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
454
463
  if ARGV[5] == "completed" then
455
464
  local dependenciesSet = parentKey .. ":dependencies"
456
465
  if rcall("SREM", dependenciesSet, jobIdKey) == 1 then
457
- updateParentDepsIfNeeded(parentKey, parentQueueKey, dependenciesSet,
458
- parentId, jobIdKey, ARGV[4])
466
+ updateParentDepsIfNeeded(parentKey, parentQueueKey,
467
+ dependenciesSet, parentId, jobIdKey,
468
+ ARGV[4])
459
469
  end
460
470
  elseif opts['fpof'] then
461
- moveParentFromWaitingChildrenToFailed(parentQueueKey, parentKey, parentId, jobIdKey, timestamp)
471
+ moveParentFromWaitingChildrenToFailed(parentQueueKey, parentKey,
472
+ parentId, jobIdKey, timestamp)
462
473
  end
463
474
  end
464
475
  -- Remove job?
@@ -489,23 +500,23 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
489
500
  end
490
501
  -- Collect metrics
491
502
  if maxMetricsSize ~= "" then
492
- collectMetrics(KEYS[12], KEYS[12]..':data', maxMetricsSize, timestamp)
503
+ collectMetrics(KEYS[12], KEYS[12] .. ':data', maxMetricsSize, timestamp)
493
504
  end
494
505
  -- Try to get next job to avoid an extra roundtrip if the queue is not closing,
495
506
  -- and not rate limited.
496
507
  if (ARGV[7] == "1") then
497
508
  -- Check if there are delayed jobs that can be promoted
498
- promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[11], KEYS[4], ARGV[8], timestamp)
509
+ promoteDelayedJobs(KEYS[7], KEYS[1], KEYS[3], KEYS[8], KEYS[11],
510
+ KEYS[4], ARGV[8], timestamp)
499
511
  -- Check if we are rate limited first.
500
512
  local pttl = getRateLimitTTL(opts, KEYS[6])
501
- if pttl > 0 then
502
- return { 0, 0, pttl }
503
- end
513
+ if pttl > 0 then return {0, 0, pttl} end
504
514
  jobId = rcall("RPOPLPUSH", KEYS[1], KEYS[2])
505
515
  if jobId == "0" then
506
516
  rcall("LREM", KEYS[2], 1, 0)
507
517
  elseif jobId then
508
- return moveJobFromWaitToActive(KEYS, ARGV[8], jobId, timestamp, opts)
518
+ return
519
+ moveJobFromWaitToActive(KEYS, ARGV[8], jobId, timestamp, opts)
509
520
  end
510
521
  -- Return the timestamp for the next delayed job if any.
511
522
  local nextTimestamp = getNextDelayedTimestamp(KEYS[7])
@@ -521,7 +532,7 @@ if rcall("EXISTS", jobIdKey) == 1 then -- // Make sure job exists
521
532
  if activeLen == 0 then
522
533
  rcall("XADD", KEYS[4], "*", "event", "drained")
523
534
  end
524
- end
535
+ end
525
536
  return 0
526
537
  else
527
538
  return -1
@@ -1 +1 @@
1
- {"version":3,"file":"moveToFinished-12.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-12.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAghBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
1
+ {"version":3,"file":"moveToFinished-12.js","sourceRoot":"","sources":["../../../src/scripts/moveToFinished-12.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA2hBf,CAAC;AACF,MAAM,CAAC,MAAM,cAAc,GAAG;IAC5B,IAAI,EAAE,gBAAgB;IACtB,OAAO;IACP,IAAI,EAAE,EAAE;CACT,CAAC"}
@@ -0,0 +1,109 @@
1
+ const content = `--[[
2
+ Retries a failed job by moving it back to the wait queue.
3
+ Input:
4
+ KEYS[1] 'active',
5
+ KEYS[2] 'wait'
6
+ KEYS[3] 'paused'
7
+ KEYS[4] job key
8
+ KEYS[5] 'meta'
9
+ KEYS[6] events stream
10
+ KEYS[7] delayed key
11
+ KEYS[8] priority key
12
+ ARGV[1] key prefix
13
+ ARGV[2] timestamp
14
+ ARGV[3] pushCmd
15
+ ARGV[4] jobId
16
+ ARGV[5] token
17
+ Events:
18
+ 'waiting'
19
+ Output:
20
+ 0 - OK
21
+ -1 - Missing key
22
+ -2 - Missing lock
23
+ ]]
24
+ local rcall = redis.call
25
+ -- Includes
26
+ --[[
27
+ Function to check for the meta.paused key to decide if we are paused or not
28
+ (since an empty list and !EXISTS are not really the same).
29
+ ]]
30
+ local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
31
+ if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
32
+ return waitKey
33
+ else
34
+ return pausedKey
35
+ end
36
+ end
37
+ --[[
38
+ Updates the delay set, by moving delayed jobs that should
39
+ be processed now to "wait".
40
+ Events:
41
+ 'waiting'
42
+ ]]
43
+ local rcall = redis.call
44
+ -- Includes
45
+ --[[
46
+ Function to add job considering priority.
47
+ ]]
48
+ local function addJobWithPriority(priorityKey, priority, targetKey, jobId)
49
+ rcall("ZADD", priorityKey, priority, jobId)
50
+ local count = rcall("ZCOUNT", priorityKey, 0, priority)
51
+ local len = rcall("LLEN", targetKey)
52
+ local id = rcall("LINDEX", targetKey, len - (count - 1))
53
+ if id then
54
+ rcall("LINSERT", targetKey, "BEFORE", id, jobId)
55
+ else
56
+ rcall("RPUSH", targetKey, jobId)
57
+ end
58
+ end
59
+ -- Try to get as much as 1000 jobs at once, and returns the nextTimestamp if
60
+ -- there are more delayed jobs to process.
61
+ local function promoteDelayedJobs(delayedKey, waitKey, priorityKey, pausedKey,
62
+ metaKey, eventStreamKey, prefix, timestamp)
63
+ local jobs = rcall("ZRANGEBYSCORE", delayedKey, 0, (timestamp + 1) * 0x1000, "LIMIT", 0, 1000)
64
+ if (#jobs > 0) then
65
+ rcall("ZREM", delayedKey, unpack(jobs))
66
+ -- check if we need to use push in paused instead of waiting
67
+ local target = getTargetQueueList(metaKey, waitKey, pausedKey)
68
+ for _, jobId in ipairs(jobs) do
69
+ local priority =
70
+ tonumber(rcall("HGET", prefix .. jobId, "priority")) or 0
71
+ if priority == 0 then
72
+ -- LIFO or FIFO
73
+ rcall("LPUSH", target, jobId)
74
+ else
75
+ addJobWithPriority(priorityKey, priority, target, jobId)
76
+ end
77
+ -- Emit waiting event
78
+ rcall("XADD", eventStreamKey, "*", "event", "waiting", "jobId",
79
+ jobId, "prev", "delayed")
80
+ rcall("HSET", prefix .. jobId, "delay", 0)
81
+ end
82
+ end
83
+ end
84
+ promoteDelayedJobs(KEYS[7], KEYS[2], KEYS[8], KEYS[3], KEYS[5], KEYS[6], ARGV[1], ARGV[2])
85
+ if rcall("EXISTS", KEYS[4]) == 1 then
86
+ if ARGV[5] ~= "0" then
87
+ local lockKey = KEYS[4] .. ':lock'
88
+ if rcall("GET", lockKey) == ARGV[5] then
89
+ rcall("DEL", lockKey)
90
+ else
91
+ return -2
92
+ end
93
+ end
94
+ local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
95
+ rcall("LREM", KEYS[1], 0, ARGV[4])
96
+ rcall(ARGV[3], target, ARGV[4])
97
+ -- Emit waiting event
98
+ rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[4], "prev", "failed");
99
+ return 0
100
+ else
101
+ return -1
102
+ end
103
+ `;
104
+ export const retryJob = {
105
+ name: 'retryJob',
106
+ content,
107
+ keys: 8,
108
+ };
109
+ //# sourceMappingURL=retryJob-8.js.map
@@ -0,0 +1 @@
1
+ {"version":3,"file":"retryJob-8.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-8.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAsGf,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "bullmq",
3
- "version": "3.0.0",
3
+ "version": "3.1.0",
4
4
  "description": "Queue for messages and jobs based on Redis",
5
5
  "main": "./dist/cjs/index.js",
6
6
  "module": "./dist/esm/index.js",
@@ -1,54 +0,0 @@
1
- --[[
2
- Moves job from active to delayed set.
3
-
4
- Input:
5
- KEYS[1] active key
6
- KEYS[2] delayed key
7
- KEYS[3] job key
8
- KEYS[4] events stream
9
- KEYS[5] delayed stream
10
-
11
- ARGV[1] delayedTimestamp
12
- ARGV[2] the id of the job
13
- ARGV[3] queue token
14
-
15
- Output:
16
- 0 - OK
17
- -1 - Missing job.
18
- -3 - Job not in active set.
19
-
20
- Events:
21
- - delayed key.
22
- ]]
23
- local rcall = redis.call
24
-
25
- if rcall("EXISTS", KEYS[3]) == 1 then
26
-
27
- if ARGV[3] ~= "0" then
28
- local lockKey = KEYS[3] .. ':lock'
29
- if rcall("GET", lockKey) == ARGV[3] then
30
- rcall("DEL", lockKey)
31
- else
32
- return -2
33
- end
34
- end
35
-
36
- local jobId = ARGV[2]
37
- local score = tonumber(ARGV[1])
38
- local delayedTimestamp = (score / 0x1000)
39
-
40
- local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
41
-
42
- if(numRemovedElements < 1) then
43
- return -3
44
- end
45
-
46
- rcall("ZADD", KEYS[2], score, jobId)
47
-
48
- rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
49
- rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
50
-
51
- return 0
52
- else
53
- return -1
54
- end
@@ -1,52 +0,0 @@
1
- "use strict";
2
- Object.defineProperty(exports, "__esModule", { value: true });
3
- exports.moveToDelayed = void 0;
4
- const content = `--[[
5
- Moves job from active to delayed set.
6
- Input:
7
- KEYS[1] active key
8
- KEYS[2] delayed key
9
- KEYS[3] job key
10
- KEYS[4] events stream
11
- KEYS[5] delayed stream
12
- ARGV[1] delayedTimestamp
13
- ARGV[2] the id of the job
14
- ARGV[3] queue token
15
- Output:
16
- 0 - OK
17
- -1 - Missing job.
18
- -3 - Job not in active set.
19
- Events:
20
- - delayed key.
21
- ]]
22
- local rcall = redis.call
23
- if rcall("EXISTS", KEYS[3]) == 1 then
24
- if ARGV[3] ~= "0" then
25
- local lockKey = KEYS[3] .. ':lock'
26
- if rcall("GET", lockKey) == ARGV[3] then
27
- rcall("DEL", lockKey)
28
- else
29
- return -2
30
- end
31
- end
32
- local jobId = ARGV[2]
33
- local score = tonumber(ARGV[1])
34
- local delayedTimestamp = (score / 0x1000)
35
- local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
36
- if(numRemovedElements < 1) then
37
- return -3
38
- end
39
- rcall("ZADD", KEYS[2], score, jobId)
40
- rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
41
- rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
42
- return 0
43
- else
44
- return -1
45
- end
46
- `;
47
- exports.moveToDelayed = {
48
- name: 'moveToDelayed',
49
- content,
50
- keys: 5,
51
- };
52
- //# sourceMappingURL=moveToDelayed-5.js.map
@@ -1 +0,0 @@
1
- {"version":3,"file":"moveToDelayed-5.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-5.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Cf,CAAC;AACW,QAAA,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
@@ -1,60 +0,0 @@
1
- "use strict";
2
- Object.defineProperty(exports, "__esModule", { value: true });
3
- exports.retryJob = void 0;
4
- const content = `--[[
5
- Retries a failed job by moving it back to the wait queue.
6
- Input:
7
- KEYS[1] 'active',
8
- KEYS[2] 'wait'
9
- KEYS[3] 'paused'
10
- KEYS[4] job key
11
- KEYS[5] 'meta'
12
- KEYS[6] events stream
13
- ARGV[1] pushCmd
14
- ARGV[2] jobId
15
- ARGV[3] token
16
- Events:
17
- 'waiting'
18
- Output:
19
- 0 - OK
20
- -1 - Missing key
21
- -2 - Missing lock
22
- ]]
23
- local rcall = redis.call
24
- -- Includes
25
- --[[
26
- Function to check for the meta.paused key to decide if we are paused or not
27
- (since an empty list and !EXISTS are not really the same).
28
- ]]
29
- local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
30
- if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
31
- return waitKey
32
- else
33
- return pausedKey
34
- end
35
- end
36
- if rcall("EXISTS", KEYS[4]) == 1 then
37
- if ARGV[3] ~= "0" then
38
- local lockKey = KEYS[4] .. ':lock'
39
- if rcall("GET", lockKey) == ARGV[3] then
40
- rcall("DEL", lockKey)
41
- else
42
- return -2
43
- end
44
- end
45
- local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
46
- rcall("LREM", KEYS[1], 0, ARGV[2])
47
- rcall(ARGV[1], target, ARGV[2])
48
- -- Emit waiting event
49
- rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[2], "prev", "failed");
50
- return 0
51
- else
52
- return -1
53
- end
54
- `;
55
- exports.retryJob = {
56
- name: 'retryJob',
57
- content,
58
- keys: 6,
59
- };
60
- //# sourceMappingURL=retryJob-6.js.map
@@ -1 +0,0 @@
1
- {"version":3,"file":"retryJob-6.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-6.ts"],"names":[],"mappings":";;;AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDf,CAAC;AACW,QAAA,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
@@ -1,54 +0,0 @@
1
- --[[
2
- Moves job from active to delayed set.
3
-
4
- Input:
5
- KEYS[1] active key
6
- KEYS[2] delayed key
7
- KEYS[3] job key
8
- KEYS[4] events stream
9
- KEYS[5] delayed stream
10
-
11
- ARGV[1] delayedTimestamp
12
- ARGV[2] the id of the job
13
- ARGV[3] queue token
14
-
15
- Output:
16
- 0 - OK
17
- -1 - Missing job.
18
- -3 - Job not in active set.
19
-
20
- Events:
21
- - delayed key.
22
- ]]
23
- local rcall = redis.call
24
-
25
- if rcall("EXISTS", KEYS[3]) == 1 then
26
-
27
- if ARGV[3] ~= "0" then
28
- local lockKey = KEYS[3] .. ':lock'
29
- if rcall("GET", lockKey) == ARGV[3] then
30
- rcall("DEL", lockKey)
31
- else
32
- return -2
33
- end
34
- end
35
-
36
- local jobId = ARGV[2]
37
- local score = tonumber(ARGV[1])
38
- local delayedTimestamp = (score / 0x1000)
39
-
40
- local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
41
-
42
- if(numRemovedElements < 1) then
43
- return -3
44
- end
45
-
46
- rcall("ZADD", KEYS[2], score, jobId)
47
-
48
- rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
49
- rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
50
-
51
- return 0
52
- else
53
- return -1
54
- end
@@ -1,49 +0,0 @@
1
- const content = `--[[
2
- Moves job from active to delayed set.
3
- Input:
4
- KEYS[1] active key
5
- KEYS[2] delayed key
6
- KEYS[3] job key
7
- KEYS[4] events stream
8
- KEYS[5] delayed stream
9
- ARGV[1] delayedTimestamp
10
- ARGV[2] the id of the job
11
- ARGV[3] queue token
12
- Output:
13
- 0 - OK
14
- -1 - Missing job.
15
- -3 - Job not in active set.
16
- Events:
17
- - delayed key.
18
- ]]
19
- local rcall = redis.call
20
- if rcall("EXISTS", KEYS[3]) == 1 then
21
- if ARGV[3] ~= "0" then
22
- local lockKey = KEYS[3] .. ':lock'
23
- if rcall("GET", lockKey) == ARGV[3] then
24
- rcall("DEL", lockKey)
25
- else
26
- return -2
27
- end
28
- end
29
- local jobId = ARGV[2]
30
- local score = tonumber(ARGV[1])
31
- local delayedTimestamp = (score / 0x1000)
32
- local numRemovedElements = rcall("LREM", KEYS[1], -1, jobId)
33
- if(numRemovedElements < 1) then
34
- return -3
35
- end
36
- rcall("ZADD", KEYS[2], score, jobId)
37
- rcall("XADD", KEYS[4], "*", "event", "delayed", "jobId", jobId, "delay", delayedTimestamp);
38
- rcall("XADD", KEYS[5], "*", "nextTimestamp", delayedTimestamp);
39
- return 0
40
- else
41
- return -1
42
- end
43
- `;
44
- export const moveToDelayed = {
45
- name: 'moveToDelayed',
46
- content,
47
- keys: 5,
48
- };
49
- //# sourceMappingURL=moveToDelayed-5.js.map
@@ -1 +0,0 @@
1
- {"version":3,"file":"moveToDelayed-5.js","sourceRoot":"","sources":["../../../src/scripts/moveToDelayed-5.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Cf,CAAC;AACF,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE,eAAe;IACrB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}
@@ -1,57 +0,0 @@
1
- const content = `--[[
2
- Retries a failed job by moving it back to the wait queue.
3
- Input:
4
- KEYS[1] 'active',
5
- KEYS[2] 'wait'
6
- KEYS[3] 'paused'
7
- KEYS[4] job key
8
- KEYS[5] 'meta'
9
- KEYS[6] events stream
10
- ARGV[1] pushCmd
11
- ARGV[2] jobId
12
- ARGV[3] token
13
- Events:
14
- 'waiting'
15
- Output:
16
- 0 - OK
17
- -1 - Missing key
18
- -2 - Missing lock
19
- ]]
20
- local rcall = redis.call
21
- -- Includes
22
- --[[
23
- Function to check for the meta.paused key to decide if we are paused or not
24
- (since an empty list and !EXISTS are not really the same).
25
- ]]
26
- local function getTargetQueueList(queueMetaKey, waitKey, pausedKey)
27
- if rcall("HEXISTS", queueMetaKey, "paused") ~= 1 then
28
- return waitKey
29
- else
30
- return pausedKey
31
- end
32
- end
33
- if rcall("EXISTS", KEYS[4]) == 1 then
34
- if ARGV[3] ~= "0" then
35
- local lockKey = KEYS[4] .. ':lock'
36
- if rcall("GET", lockKey) == ARGV[3] then
37
- rcall("DEL", lockKey)
38
- else
39
- return -2
40
- end
41
- end
42
- local target = getTargetQueueList(KEYS[5], KEYS[2], KEYS[3])
43
- rcall("LREM", KEYS[1], 0, ARGV[2])
44
- rcall(ARGV[1], target, ARGV[2])
45
- -- Emit waiting event
46
- rcall("XADD", KEYS[6], "*", "event", "waiting", "jobId", ARGV[2], "prev", "failed");
47
- return 0
48
- else
49
- return -1
50
- end
51
- `;
52
- export const retryJob = {
53
- name: 'retryJob',
54
- content,
55
- keys: 6,
56
- };
57
- //# sourceMappingURL=retryJob-6.js.map
@@ -1 +0,0 @@
1
- {"version":3,"file":"retryJob-6.js","sourceRoot":"","sources":["../../../src/scripts/retryJob-6.ts"],"names":[],"mappings":"AAAA,MAAM,OAAO,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkDf,CAAC;AACF,MAAM,CAAC,MAAM,QAAQ,GAAG;IACtB,IAAI,EAAE,UAAU;IAChB,OAAO;IACP,IAAI,EAAE,CAAC;CACR,CAAC"}