qless 0.9.1

data/lib/qless/qless-core/config.lua

@@ -0,0 +1,44 @@
+-- config(0, 'get', [option])
+-- config(0, 'set', option, value)
+-- config(0, 'unset', option)
+-- -------------------------------------------------------------------------------------------------------
+-- This script provides an interface to get, set, and unset configuration
+-- options.
+--
+-- Args:
+--    1) [option]
+
+if #KEYS > 0 then error('Config(): No keys should be provided') end
+
+local command = ARGV[1]
+
+local defaults = {
+	['application']        = 'qless',
+	['heartbeat']          = 60,
+	['stats-history']      = 30,
+	['histogram-history']  = 7,
+	['jobs-history-count'] = 50000,
+	['jobs-history']       = 604800
+}
+
+if command == 'get' then
+	if ARGV[2] then
+		return redis.call('hget', 'ql:config', ARGV[2]) or defaults[ARGV[2]]
+	else
+		-- Inspired by redis-lua https://github.com/nrk/redis-lua/blob/version-2.0/src/redis.lua
+		local reply = redis.call('hgetall', 'ql:config')
+	    for i = 1, #reply, 2 do defaults[reply[i]] = reply[i + 1] end
+		return cjson.encode(defaults)
+	end
+elseif command == 'set' then
+	local option = assert(ARGV[2], 'Config(): Arg "option" missing')
+	local value  = assert(ARGV[3], 'Config(): Arg "value" missing')
+	redis.call('hset', 'ql:config', option, value)
+elseif command == 'unset' then
+	local option = assert(ARGV[2], 'Config(): Arg "option" missing')
+	redis.call('hdel', 'ql:config', option)
+else
+	error('Config(): Unrecognized command ' .. command)
+end
+
+

data/lib/qless/qless-core/depends.lua

@@ -0,0 +1,65 @@
+-- Depends(0, jid, ('on', [jid, [jid, [...]]]) | ('off', ('all' | [jid, [jid, [...]]]))
+-- ------------------------------------------------------------------------------------
+-- Add or remove dependencies a job has. If 'on' is provided, the provided jids are 
+-- added as dependencies. If 'off' and 'all' are provided, then all the current dependencies
+-- are removed. If 'off' is provided and the next argument is not 'all', then those
+-- jids are removed as dependencies.
+--
+-- If a job is not already in the 'depends' state, then this call will return false.
+-- Otherwise, it will return true
+--
+-- Args:
+--    1) jid
+
+if #KEYS > 0 then error('Depends(): No Keys should be provided') end
+
+local jid     = assert(ARGV[1], 'Depends(): Arg "jid" missing.')
+local command = assert(ARGV[2], 'Depends(): Arg 2 missing')
+
+if redis.call('hget', 'ql:j:' .. jid, 'state') ~= 'depends' then
+	return false
+end
+
+if ARGV[2] == 'on' then
+	-- These are the jids we legitimately have to wait on
+	for i=3,#ARGV do
+		local j = ARGV[i]
+		-- Make sure it's something other than 'nil' or complete.
+		local state = redis.call('hget', 'ql:j:' .. j, 'state')
+		if (state and state ~= 'complete') then
+			redis.call('sadd', 'ql:j:' .. j .. '-dependents'  , jid)
+			redis.call('sadd', 'ql:j:' .. jid .. '-dependencies', j)
+		end
+	end
+	return true
+elseif ARGV[2] == 'off' then
+	if ARGV[3] == 'all' then
+		for i, j in ipairs(redis.call('smembers', 'ql:j:' .. jid .. '-dependencies')) do
+			redis.call('srem', 'ql:j:' .. j .. '-dependents', jid)
+		end
+		redis.call('del', 'ql:j:' .. jid .. '-dependencies')
+		local q, p = unpack(redis.call('hmget', 'ql:j:' .. jid, 'queue', 'priority'))
+		if q then
+			redis.call('zrem', 'ql:q:' .. q .. '-depends', jid)
+			redis.call('zadd', 'ql:q:' .. q .. '-work', p, jid)
+			redis.call('hset', 'ql:j:' .. jid, 'state', 'waiting')
+		end
+	else
+		for i=3,#ARGV do
+			local j = ARGV[i]
+			redis.call('srem', 'ql:j:' .. j .. '-dependents', jid)
+			redis.call('srem', 'ql:j:' .. jid .. '-dependencies', j)
+			if redis.call('scard', 'ql:j:' .. jid .. '-dependencies') == 0 then
+				local q, p = unpack(redis.call('hmget', 'ql:j:' .. jid, 'queue', 'priority'))
+				if q then
+					redis.call('zrem', 'ql:q:' .. q .. '-depends', jid)
+					redis.call('zadd', 'ql:q:' .. q .. '-work', p, jid)
+					redis.call('hset', 'ql:j:' .. jid, 'state', 'waiting')
+				end
+			end
+		end
+	end
+	return true
+else
+	error('Depends(): Second arg must be "on" or "off"')
+end

data/lib/qless/qless-core/fail.lua

@@ -0,0 +1,107 @@
+-- Fail(0, jid, worker, group, message, now, [data])
+-- -------------------------------------------------
+-- Mark the particular job as failed, with the provided group, and a more specific
+-- message. By `group`, we mean some phrase that might be one of several categorical
+-- modes of failure. The `message` is something more job-specific, like perhaps
+-- a traceback.
+-- 
+-- This method should __not__ be used to note that a job has been dropped or has 
+-- failed in a transient way. This method __should__ be used to note that a job has
+-- something really wrong with it that must be remedied.
+-- 
+-- The motivation behind the `group` is so that similar errors can be grouped together.
+-- Optionally, updated data can be provided for the job. A job in any state can be
+-- marked as failed. If it has been given to a worker as a job, then its subsequent
+-- requests to heartbeat or complete that job will fail. Failed jobs are kept until
+-- they are canceled or completed. __Returns__ the id of the failed job if successful,
+-- or `False` on failure.
+--
+-- Args:
+--    1) jid
+--    2) worker
+--    3) group
+--    4) message
+--    5) the current time
+--    6) [data]
+
+if #KEYS > 0 then error('Fail(): No Keys should be provided') end
+
+local jid     = assert(ARGV[1]          , 'Fail(): Arg "jid" missing')
+local worker  = assert(ARGV[2]          , 'Fail(): Arg "worker" missing')
+local group   = assert(ARGV[3]          , 'Fail(): Arg "group" missing')
+local message = assert(ARGV[4]          , 'Fail(): Arg "message" missing')
+local now     = assert(tonumber(ARGV[5]), 'Fail(): Arg "now" missing or malformed: ' .. (ARGV[5] or 'nil'))
+local data    = ARGV[6]
+
+-- The bin is midnight of the provided day
+-- 24 * 60 * 60 = 86400
+local bin = now - (now % 86400)
+
+if data then
+	data = cjson.decode(data)
+end
+
+-- First things first, we should get the history
+local history, queue, state = unpack(redis.call('hmget', 'ql:j:' .. jid, 'history', 'queue', 'state'))
+
+-- If the job has been completed, we cannot fail it
+if state ~= 'running' then
+	return false
+end
+
+if redis.call('zscore', 'ql:tracked', jid) ~= false then
+	redis.call('publish', 'failed', jid)
+end
+
+-- Remove this job from the jobs that the worker that was running it has
+redis.call('zrem', 'ql:w:' .. worker .. ':jobs', jid)
+
+-- Now, take the element of the history for which our provided worker is the worker, and update 'failed'
+history = cjson.decode(history or '[]')
+if #history > 0 then
+	for i=#history,1,-1 do
+		if history[i]['worker'] == worker then
+			history[i]['failed'] = math.floor(now)
+		end
+	end
+else
+	history = {
+		{
+			worker = worker,
+			failed = math.floor(now)
+		}
+	}
+end
+
+-- Increment the number of failures for that queue for the
+-- given day.
+redis.call('hincrby', 'ql:s:stats:' .. bin .. ':' .. queue, 'failures', 1)
+redis.call('hincrby', 'ql:s:stats:' .. bin .. ':' .. queue, 'failed'  , 1)
+
+-- Now remove the instance from the schedule, and work queues for the queue it's in
+redis.call('zrem', 'ql:q:' .. queue .. '-work', jid)
+redis.call('zrem', 'ql:q:' .. queue .. '-locks', jid)
+redis.call('zrem', 'ql:q:' .. queue .. '-scheduled', jid)
+
+-- The reason that this appears here is that the above will fail if the job doesn't exist
+if data then
+	redis.call('hset', 'ql:j:' .. jid, 'data', cjson.encode(data))
+end
+
+redis.call('hmset', 'ql:j:' .. jid, 'state', 'failed', 'worker', '',
+	'expires', '', 'history', cjson.encode(history), 'failure', cjson.encode({
+		['group']   = group,
+		['message'] = message,
+		['when']    = math.floor(now),
+		['worker']  = worker
+	}))
+
+-- Add this group of failure to the list of failures
+redis.call('sadd', 'ql:failures', group)
+-- And add this particular instance to the failed groups
+redis.call('lpush', 'ql:f:' .. group, jid)
+
+-- Here is where we'd intcrement stats about the particular stage
+-- and possibly the workers
+
+return jid

data/lib/qless/qless-core/failed.lua

@@ -0,0 +1,83 @@
+-- Failed(0, [group, [start, [limit]]])
+-- ------------------------------------
+-- If no group is provided, this returns a JSON blob of the counts of the various
+-- groups of failures known. If a group is provided, it will report up to `limit`
+-- from `start` of the jobs affected by that issue. __Returns__ a JSON blob.
+-- 
+-- 	# If no group, then...
+-- 	{
+-- 		'group1': 1,
+-- 		'group2': 5,
+-- 		...
+-- 	}
+-- 	
+-- 	# If a group is provided, then...
+-- 	{
+--      'total': 20,
+-- 		'jobs': [
+-- 			{
+-- 				# All the normal keys for a job
+-- 				'jid': ...,
+-- 				'data': ...
+-- 				# The message for this particular instance
+-- 				'message': ...,
+-- 				'group': ...,
+-- 			}, ...
+-- 		]
+-- 	}
+--
+-- Args:
+--    1) [group]
+--    2) [start]
+--    3) [limit]
+
+if #KEYS > 0 then error('Failed(): No Keys should be provided') end
+
+local group = ARGV[1]
+local start = assert(tonumber(ARGV[2] or  0), 'Failed(): Arg "start" is not a number: ' .. (ARGV[2] or 'nil'))
+local limit = assert(tonumber(ARGV[3] or 25), 'Failed(): Arg "limit" is not a number: ' .. (ARGV[3] or 'nil'))
+
+if group then
+	-- If a group was provided, then we should do paginated lookup into that
+	local response = {
+		total = redis.call('llen', 'ql:f:' .. group),
+		jobs  = {}
+	}
+	local jids = redis.call('lrange', 'ql:f:' .. group, start, limit)
+	for index, jid in ipairs(jids) do
+		local job = redis.call(
+		    'hmget', 'ql:j:' .. jid, 'jid', 'klass', 'state', 'queue', 'worker', 'priority',
+			'expires', 'retries', 'remaining', 'data', 'tags', 'history', 'failure')
+		
+		table.insert(response.jobs, {
+		    jid          = job[1],
+			klass        = job[2],
+		    state        = job[3],
+		    queue        = job[4],
+			worker       = job[5] or '',
+			tracked      = redis.call('zscore', 'ql:tracked', jid) ~= false,
+			priority     = tonumber(job[6]),
+			expires      = tonumber(job[7]) or 0,
+			retries      = tonumber(job[8]),
+			remaining    = tonumber(job[9]),
+			data         = cjson.decode(job[10]),
+			tags         = cjson.decode(job[11]),
+		    history      = cjson.decode(job[12]),
+			failure      = cjson.decode(job[13] or '{}'),
+			dependents   = redis.call('smembers', 'ql:j:' .. jid .. '-dependents'),
+			-- A job in the failed state can not have dependencies
+			-- because it has been popped off of a queue, which 
+			-- means all of its dependencies have been satisfied
+			dependencies = {}
+		})
+	end
+	return cjson.encode(response)
+else
+	-- Otherwise, we should just list all the known failure groups we have
+	local response = {}
+	local groups = redis.call('smembers', 'ql:failures')
+	for index, group in ipairs(groups) do
+		response[group] = redis.call('llen', 'ql:f:' .. group)
+	end
+	return cjson.encode(response)
+end

data/lib/qless/qless-core/get.lua

@@ -0,0 +1,37 @@
+-- This gets all the data associated with the job with the
+-- provided id.
+--
+-- Args:
+--    1) jid
+
+if #KEYS > 0 then error('Get(): No Keys should be provided') end
+
+local jid = assert(ARGV[1], 'Get(): Arg "jid" missing')
+
+-- Let's get all the data we can
+local job = redis.call(
+    'hmget', 'ql:j:' .. jid, 'jid', 'klass', 'state', 'queue', 'worker', 'priority',
+	'expires', 'retries', 'remaining', 'data', 'tags', 'history', 'failure')
+
+if not job[1] then
+	return false
+end
+		
+return cjson.encode({
+    jid          = job[1],
+	klass        = job[2],
+    state        = job[3],
+    queue        = job[4],
+	worker       = job[5] or '',
+	tracked      = redis.call('zscore', 'ql:tracked', jid) ~= false,
+	priority     = tonumber(job[6]),
+	expires      = tonumber(job[7]) or 0,
+	retries      = tonumber(job[8]),
+	remaining    = tonumber(job[9]),
+	data         = cjson.decode(job[10]),
+	tags         = cjson.decode(job[11]),
+    history      = cjson.decode(job[12]),
+	failure      = cjson.decode(job[13] or '{}'),
+	dependents   = redis.call('smembers', 'ql:j:' .. jid .. '-dependents'),
+	dependencies = redis.call('smembers', 'ql:j:' .. jid .. '-dependencies')
+})

data/lib/qless/qless-core/heartbeat.lua

@@ -0,0 +1,50 @@
+-- This scripts conducts a heartbeat for a job, and returns
+-- either the new expiration or False if the lock has been
+-- given to another node
+--
+-- Args:
+--    1) jid
+--    2) worker
+--    3) now
+--    4) [data]
+
+if #KEYS > 0 then error('Heartbeat(): No Keys should be provided') end
+
+local jid    = assert(ARGV[1]          , 'Heartbeat(): Arg "jid" missing')
+local worker = assert(ARGV[2]          , 'Heartbeat(): Arg "worker" missing')
+local now    = assert(tonumber(ARGV[3]), 'Heartbeat(): Arg "now" missing')
+local data   = ARGV[4]
+
+-- We should find the heartbeat interval for this queue
+-- heartbeat. First, though, we need to find the queue
+-- this particular job is in
+local queue     = redis.call('hget', 'ql:j:' .. jid, 'queue') or ''
+local _hb, _qhb = unpack(redis.call('hmget', 'ql:config', 'heartbeat', queue .. '-heartbeat'))
+local expires   = now + tonumber(_qhb or _hb or 60)
+
+if data then
+	data = cjson.decode(data)
+end
+
+-- First, let's see if the worker still owns this job, and there is a worker
+if redis.call('hget', 'ql:j:' .. jid, 'worker') ~= worker or #worker == 0 then
+    return false
+else
+    -- Otherwise, optionally update the user data, and the heartbeat
+    if data then
+        -- I don't know if this is wise, but I'm decoding and encoding
+        -- the user data to hopefully ensure its sanity
+        redis.call('hmset', 'ql:j:' .. jid, 'expires', expires, 'worker', worker, 'data', cjson.encode(data))
+    else
+        redis.call('hmset', 'ql:j:' .. jid, 'expires', expires, 'worker', worker)
+    end
+	
+	-- Update hwen this job was last updated on that worker
+	-- Add this job to the list of jobs handled by this worker
+	redis.call('zadd', 'ql:w:' .. worker .. ':jobs', expires, jid)
+	
+    -- And now we should just update the locks
+    local queue = redis.call('hget', 'ql:j:' .. jid, 'queue')
+    redis.call('zadd', 'ql:q:'.. queue .. '-locks', expires, jid)
+    return expires
+end

data/lib/qless/qless-core/jobs.lua

@@ -0,0 +1,41 @@
+-- Jobs(0, 'complete' | (('stalled' | 'running' | 'scheduled' | 'depends', 'recurring'), now, queue) [offset, [count]])
+-- -------------------------------------------------------------------------------------------------------
+-- 
+-- Return all the job ids currently considered to be in the provided state
+-- in a particular queue. The response is a list of job ids:
+-- 
+-- 	[
+--		jid1, 
+--		jid2,
+--		...
+--	]
+
+if #KEYS > 0 then
+	error('Jobs(): Got '.. #KEYS .. ' expected 0 KEYS arguments')
+end
+
+local t      = assert(ARGV[1]                , 'Jobs(): Arg "type" missing')
+if t == 'complete' then
+	local offset = assert(tonumber(ARGV[2] or 0) , 'Jobs(): Arg "offset" not a number: ' .. tostring(ARGV[2]))
+	local count  = assert(tonumber(ARGV[3] or 25), 'Jobs(): Arg "count" not a number: ' .. tostring(ARGV[3]))
+	return redis.call('zrevrange', 'ql:completed', offset, offset + count - 1)
+else
+	local now    = assert(tonumber(ARGV[2])      , 'Jobs(): Arg "now" missing or not a number: ' .. tostring(ARGV[2]))
+	local queue  = assert(ARGV[3]                , 'Jobs(): Arg "queue" missing')
+	local offset = assert(tonumber(ARGV[4] or 0) , 'Jobs(): Arg "offset" not a number: ' .. tostring(ARGV[4]))
+	local count  = assert(tonumber(ARGV[5] or 25), 'Jobs(): Arg "count" not a number: ' .. tostring(ARGV[5]))
+
+	if t == 'running' then
+		return redis.call('zrangebyscore', 'ql:q:' .. queue .. '-locks', now, 133389432700, 'limit', offset, count)
+	elseif t == 'stalled' then
+		return redis.call('zrangebyscore', 'ql:q:' .. queue .. '-locks', 0, now, 'limit', offset, count)
+	elseif t == 'scheduled' then
+		return redis.call('zrange', 'ql:q:' .. queue .. '-scheduled', offset, offset + count - 1)
+	elseif t == 'depends' then
+		return redis.call('zrange', 'ql:q:' .. queue .. '-depends', offset, offset + count - 1)
+	elseif t == 'recurring' then
+		return redis.call('zrange', 'ql:q:' .. queue .. '-recur', offset, offset + count - 1)
+	else
+		error('Jobs(): Unknown type "' .. t .. '"')
+	end
+end

data/lib/qless/qless-core/peek.lua

@@ -0,0 +1,155 @@
+-- This script takes the name of the queue and then checks
+-- for any expired locks, then inserts any scheduled items
+-- that are now valid, and lastly returns any work items 
+-- that can be handed over.
+--
+-- Keys:
+--    1) queue name
+-- Args:
+--    1) the number of items to return
+--    2) the current time
+
+if #KEYS ~= 1 then
+	if #KEYS < 1 then
+		error('Peek(): Expected 1 KEYS argument')
+	else
+		error('Peek(): Got ' .. #KEYS .. ', expected 1 KEYS argument')
+	end
+end
+
+local queue   = assert(KEYS[1]           , 'Peek(): Key "queue" missing')
+local key     = 'ql:q:' .. queue
+local count   = assert(tonumber(ARGV[1]) , 'Peek(): Arg "count" missing or not a number: ' .. (ARGV[2] or 'nil'))
+local now     = assert(tonumber(ARGV[2]) , 'Peek(): Arg "now" missing or not a number: ' .. (ARGV[3] or 'nil'))
+
+-- These are the ids that we're going to return
+local keys = {}
+
+-- Iterate through all the expired locks and add them to the list
+-- of keys that we'll return
+for index, jid in ipairs(redis.call('zrangebyscore', key .. '-locks', 0, now, 'LIMIT', 0, count)) do
+    table.insert(keys, jid)
+end
+
+-- If we still need jobs in order to meet demand, then we should
+-- look for all the recurring jobs that need jobs run
+if #keys < count then
+	local r = redis.call('zrangebyscore', key .. '-recur', 0, now)
+	for index, jid in ipairs(r) do
+		-- For each of the jids that need jobs scheduled, first
+		-- get the last time each of them was run, and then increment
+		-- it by its interval. While this time is less than now,
+		-- we need to keep putting jobs on the queue
+		local klass, data, priority, tags, retries, interval = unpack(redis.call('hmget', 'ql:r:' .. jid, 'klass', 'data', 'priority', 'tags', 'retries', 'interval'))
+		local _tags = cjson.decode(tags)
+		
+		while math.floor(tonumber(redis.call('zscore', key .. '-recur', jid))) < now do
+			local count = redis.call('hincrby', 'ql:r:' .. jid, 'count', 1)
+			
+			-- Add this job to the list of jobs tagged with whatever tags were supplied
+			for i, tag in ipairs(_tags) do
+				redis.call('zadd', 'ql:t:' .. tag, now, jid .. '-' .. count)
+				redis.call('zincrby', 'ql:tags', 1, tag)
+			end
+			
+			-- First, let's save its data
+			redis.call('hmset', 'ql:j:' .. jid .. '-' .. count,
+			    'jid'      , jid .. '-' .. count,
+				'klass'    , klass,
+			    'data'     , data,
+			    'priority' , priority,
+			    'tags'     , tags,
+			    'state'    , 'waiting',
+			    'worker'   , '',
+				'expires'  , 0,
+			    'queue'    , queue,
+				'retries'  , retries,
+				'remaining', retries,
+			    'history'  , cjson.encode({{
+					q     = queue,
+					put   = math.floor(now)
+				}}))
+			
+			-- Now, if a delay was provided, and if it's in the future,
+			-- then we'll have to schedule it. Otherwise, we're just
+			-- going to add it to the work queue.
+			redis.call('zadd', key .. '-work', priority - (now / 10000000000), jid .. '-' .. count)
+			
+			redis.call('zincrby', key .. '-recur', interval, jid)
+		end
+	end
+end
+
+-- Now we've checked __all__ the locks for this queue the could
+-- have expired, and are no more than the number requested. If
+-- we still need values in order to meet the demand, then we 
+-- should check if any scheduled items, and if so, we should 
+-- insert them to ensure correctness when pulling off the next
+-- unit of work.
+if #keys < count then    
+    -- zadd is a list of arguments that we'll be able to use to
+    -- insert into the work queue
+    local zadd = {}
+    local r = redis.call('zrangebyscore', key .. '-scheduled', 0, now, 'LIMIT', 0, (count - #keys))
+    for index, jid in ipairs(r) do
+        -- With these in hand, we'll have to go out and find the 
+        -- priorities of these jobs, and then we'll insert them
+        -- into the work queue and then when that's complete, we'll
+        -- remove them from the scheduled queue
+        table.insert(zadd, tonumber(redis.call('hget', 'ql:j:' .. jid, 'priority') or 0))
+        table.insert(zadd, jid)
+		-- We should also update them to have the state 'waiting'
+		-- instead of 'scheduled'
+		redis.call('hset', 'ql:j:' .. jid, 'state', 'waiting')
+    end
+    
+	if #zadd > 0 then
+	    -- Now add these to the work list, and then remove them
+	    -- from the scheduled list
+	    redis.call('zadd', key .. '-work', unpack(zadd))
+	    redis.call('zrem', key .. '-scheduled', unpack(r))
+	end
+    
+    -- And now we should get up to the maximum number of requested
+    -- work items from the work queue.
+    for index, jid in ipairs(redis.call('zrevrange', key .. '-work', 0, (count - #keys) - 1)) do
+        table.insert(keys, jid)
+    end
+end
+
+-- Alright, now the `keys` table is filled with all the job
+-- ids which we'll be returning. Now we need to get the 
+-- metadeata about each of these, update their metadata to
+-- reflect which worker they're on, when the lock expires, 
+-- etc., add them to the locks queue and then we have to 
+-- finally return a list of json blobs
+
+local response = {}
+for index, jid in ipairs(keys) do
+	local job = redis.call(
+	    'hmget', 'ql:j:' .. jid, 'jid', 'klass', 'state', 'queue', 'worker', 'priority',
+		'expires', 'retries', 'remaining', 'data', 'tags', 'history', 'failure')
+	
+	table.insert(response, cjson.encode({
+	    jid          = job[1],
+		klass        = job[2],
+	    state        = job[3],
+	    queue        = job[4],
+		worker       = job[5] or '',
+		tracked      = redis.call('zscore', 'ql:tracked', jid) ~= false,
+		priority     = tonumber(job[6]),
+		expires      = tonumber(job[7]) or 0,
+		retries      = tonumber(job[8]),
+		remaining    = tonumber(job[9]),
+		data         = cjson.decode(job[10]),
+		tags         = cjson.decode(job[11]),
+	    history      = cjson.decode(job[12]),
+		failure      = cjson.decode(job[13] or '{}'),
+		dependents   = redis.call('smembers', 'ql:j:' .. jid .. '-dependents'),
+		-- A job in the waiting state can not have dependencies
+		dependencies = {}
+		
+	}))
+end
+
+return response