qless 0.9.3 → 0.10.0

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

@@ -1,79 +0,0 @@
--- Track(0)
--- Track(0, ('track' | 'untrack'), jid, now)
--- ------------------------------------------
--- If no arguments are provided, it returns details of all currently-tracked jobs.
--- If the first argument is 'track', then it will start tracking the job associated
--- with that id, and 'untrack' stops tracking it. In this context, tracking is
--- nothing more than saving the job to a list of jobs that are considered special.
--- __Returns__ JSON:
--- 
--- 	{
--- 		'jobs': [
--- 			{
--- 				'jid': ...,
--- 				# All the other details you'd get from 'get'
--- 			}, {
--- 				...
--- 			}
--- 		], 'expired': [
--- 			# These are all the jids that are completed and whose data expired
--- 			'deadbeef',
--- 			...,
--- 			...,
--- 		]
--- 	}
---
-
-if #KEYS ~= 0 then
-	error('Track(): No keys expected. Got ' .. #KEYS)
-end
-
-if ARGV[1] ~= nil then
-	local jid = assert(ARGV[2]          , 'Track(): Arg "jid" missing')
-	local now = assert(tonumber(ARGV[3]), 'Track(): Arg "now" missing or not a number: ' .. (ARGV[3] or 'nil'))
-	if string.lower(ARGV[1]) == 'track' then
-		redis.call('publish', 'track', jid)
-		return redis.call('zadd', 'ql:tracked', now, jid)
-	elseif string.lower(ARGV[1]) == 'untrack' then
-		redis.call('publish', 'untrack', jid)
-		return redis.call('zrem', 'ql:tracked', jid)
-	else
-		error('Track(): Unknown action "' .. ARGV[1] .. '"')
-	end
-else
-	local response = {
-		jobs = {},
-		expired = {}
-	}
-	local jids = redis.call('zrange', 'ql:tracked', 0, -1)
-	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')
-		
-		if job[1] then
-			table.insert(response.jobs, {
-			    jid          = job[1],
-				klass        = job[2],
-			    state        = job[3],
-			    queue        = job[4],
-				worker       = job[5] or '',
-				tracked      = true,
-				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')
-				
-			})
-		else
-			table.insert(response.expired, jid)
-		end
-	end
-	return cjson.encode(response)
-end

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

@@ -1,54 +0,0 @@
--- Unfail(0, now, group, queue, [count])
---
--- Move `count` jobs out of the failed state and into the provided queue
-
-if #KEYS ~= 0 then
-    error('Unfail(): Expected 0 KEYS arguments')
-end
-
-local now   = assert(tonumber(ARGV[1]), 'Unfail(): Arg "now" missing'  )
-local group = assert(ARGV[2]          , 'Unfail(): Arg "group" missing')
-local queue = assert(ARGV[3]          , 'Unfail(): Arg "queue" missing')
-local count = assert(tonumber(ARGV[4] or 25),
-    'Unfail(): Arg "count" not a number: ' .. tostring(ARGV[4]))
-
--- Get up to that many jobs, and we'll put them in the appropriate queue
-local jids = redis.call('lrange', 'ql:f:' .. group, -count, -1)
-
--- Get each job's original number of retries, 
-local jobs = {}
-for index, jid in ipairs(jids) do
-    local packed = redis.call('hgetall', 'ql:j:' .. jid)
-    local unpacked = {}
-    for i = 1, #packed, 2 do unpacked[packed[i]] = packed[i + 1] end
-    table.insert(jobs, unpacked)
-end
-
--- And now set each job's state, and put it into the appropriate queue
-local toinsert = {}
-for index, job in ipairs(jobs) do
-    job.history = cjson.decode(job.history or '{}')
-    table.insert(job.history, {
-        q   = queue,
-        put = math.floor(now)
-    })
-    redis.call('hmset', 'ql:j:' .. job.jid,
-        'state'    , 'waiting',
-        'worker'   , '',
-        'expires'  , 0,
-        'queue'    , queue,
-        'remaining', job.retries or 5,
-        'history'  , cjson.encode(job.history))
-    table.insert(toinsert, job.priority - (now / 10000000000))
-    table.insert(toinsert, job.jid)
-end
-
-redis.call('zadd', 'ql:q:' .. queue .. '-work', unpack(toinsert))
-
--- Remove these jobs from the failed state
-redis.call('ltrim', 'ql:f:' .. group, 0, -count - 1)
-if (redis.call('llen', 'ql:f:' .. group) == 0) then
-    redis.call('srem', 'ql:failures', group)
-end
-
-return #jids

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

@@ -1,12 +0,0 @@
--- This script takes the name of the queue(s) and removes it
--- from the ql:paused_queues set.
---
--- Args: The list of queues to pause.
-
-if #KEYS > 0 then error('Pause(): No Keys should be provided') end
-if #ARGV < 1 then error('Pause(): Must provide at least one queue to pause') end
-
-local key = 'ql:paused_queues'
-
-redis.call('srem', key, unpack(ARGV))
-

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

@@ -1,69 +0,0 @@
--- Workers(0, now, [worker])
--- -------------------------
--- Provide data about all the workers, or if a specific worker is provided, then
--- which jobs that worker is responsible for. If no worker is provided, expect a
--- response of the form:
--- 
--- 	[
--- 		# This is sorted by the recency of activity from that worker
--- 		{
--- 			'name'   : 'hostname1-pid1',
--- 			'jobs'   : 20,
--- 			'stalled': 0
--- 		}, {
--- 			...
--- 		}
--- 	]
--- 
--- If a worker id is provided, then expect a response of the form:
--- 
--- 	{
--- 		'jobs': [
--- 			jid1,
--- 			jid2,
--- 			...
--- 		], 'stalled': [
--- 			jid1,
--- 			...
--- 		]
--- 	}
---
-if #KEYS > 0 then
-	error('Workers(): No key arguments expected')
-end
-
-local now = assert(tonumber(ARGV[1]), 'Workers(): Arg "now" missing or not a number: ' .. (ARGV[1] or 'nil'))
-
--- Clean up all the workers' job lists if they're too old. This is determined
--- by the `max-worker-age` configuration, defaulting to the last day. Seems
--- like a 'reasonable' default
-local interval = tonumber(
-	redis.call('hget', 'ql:config', 'max-worker-age')) or 86400
-
-local workers  = redis.call('zrangebyscore', 'ql:workers', 0, now - interval)
-for index, worker in ipairs(workers) do
-	redis.call('del', 'ql:w:' .. worker .. ':jobs')
-end
-
--- And now remove them from the list of known workers
-redis.call('zremrangebyscore', 'ql:workers', 0, now - interval)
-
-if #ARGV == 1 then
-	local response = {}
-	local workers = redis.call('zrevrange', 'ql:workers', 0, -1)
-	for index, worker in ipairs(workers) do
-		table.insert(response, {
-			name    = worker,
-			jobs    = redis.call('zcount', 'ql:w:' .. worker .. ':jobs', now, now + 8640000),
-			stalled = redis.call('zcount', 'ql:w:' .. worker .. ':jobs', 0, now)
-		})
-	end
-	return cjson.encode(response)
-else
-	local worker = assert(ARGV[2], 'Workers(): Arg "worker" missing.')
-	local response = {
-		jobs    = redis.call('zrevrangebyscore', 'ql:w:' .. worker .. ':jobs', now + 8640000, now),
-		stalled = redis.call('zrevrangebyscore', 'ql:w:' .. worker .. ':jobs', now, 0)
-	}
-	return cjson.encode(response)
-end

data/lib/qless/wait_until.rb

@@ -1,19 +0,0 @@
-module Qless
-  module WaitUntil
-    TimeoutError = Class.new(StandardError)
-
-    def wait_until(timeout)
-      timeout_at = Time.now + timeout
-
-      loop do
-        return if yield
-        sleep 0.002
-        if Time.now > timeout_at
-          raise TimeoutError, "Timed out after #{timeout} seconds"
-        end
-      end
-    end
-
-    module_function :wait_until
-  end
-end