local state = redis.call('HGET', KEYS[1], 'state')
if ARGV[11] == 'FANOUT' then
local rootState = redis.call('HGET', KEYS[4], 'state')
if rootState ~= 'COMMITTED' and rootState ~= 'WAITING_CHILDREN' then return {'NOT_COMMITTED'} end
if redis.call('HGET', KEYS[1], 'targetNodeIdentity') ~= ARGV[12]
or redis.call('HGET', KEYS[1], 'assignmentEpoch') ~= ARGV[13] then return {'STALE_ASSIGNMENT'} end
local time = redis.call('TIME')
local now = time[1] * 1000 + math.floor(time[2] / 1000)
if state == 'RUNNING' and redis.call('HGET', KEYS[1], 'owner') == ARGV[3] then
if tonumber(redis.call('HGET', KEYS[1], 'leaseUntil') or '0') <= now then
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
return {'LEASE_EXPIRED'}
end
local leaseUntil = now + tonumber(ARGV[5])
redis.call('HSET', KEYS[1], 'leaseUntil', leaseUntil)
redis.call('ZADD', KEYS[2], leaseUntil, ARGV[14] .. ':' .. ARGV[15])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'ADOPTED', redis.call('HGET', KEYS[1], 'attempt'),
redis.call('HGET', KEYS[1], 'attemptToken'), tostring(now), tostring(leaseUntil)}
end
if state ~= 'RECEIVED' then return {'STATE_MISMATCH'} end
redis.call('HDEL', KEYS[1], 'capacityDeferredAt', 'capacityRouteCount', 'capacityRouteBlockedAt')
local function reject(code, expectation)
redis.call('HSET', KEYS[1], 'rejectedCode', code, 'rejectedBy', ARGV[3],
'rejectedExpectation', expectation, 'rejectedAt', now)
return {code}
end
if redis.call('HGET', KEYS[1], 'fanoutId') ~= ARGV[14]
or redis.call('HGET', KEYS[1], 'seq') ~= ARGV[15]
or redis.call('HGET', KEYS[1], 'workerName') ~= ARGV[1]
or redis.call('HGET', KEYS[1], 'executionKey') ~= ARGV[16] then
return reject('IDENTITY_MISMATCH', 'executionKey=' .. ARGV[16])
end
if (redis.call('HGET', KEYS[1], 'schedulerQualifier') or '') ~= ARGV[19] then
return reject('SOURCE_MISMATCH', 'source=' .. ARGV[19])
end
if tonumber(redis.call('HGET', KEYS[1], 'protocolVersion') or '0') > tonumber(ARGV[20]) then
return reject('PROTOCOL_UNSUPPORTED', 'protocol<=' .. ARGV[20])
end
local shardCodec = redis.call('HGET', KEYS[1], 'wireCodec') or ''
if redis.call('HGET', KEYS[1], 'contractRevision') ~= ARGV[21]
or redis.call('HGET', KEYS[1], 'schemaId') ~= ARGV[22]
or not string.find(',' .. ARGV[23] .. ',', ',' .. shardCodec .. ',', 1, true) then
return reject('CONTRACT_MISMATCH', 'contract=' .. ARGV[21] .. '|' .. ARGV[22] .. '|' .. ARGV[23])
end
redis.call('HDEL', KEYS[1], 'rejectedCode', 'rejectedBy', 'rejectedExpectation', 'rejectedAt')
local previousToken = tonumber(redis.call('HGET', KEYS[1], 'attemptToken')) or 0
local token = redis.call('HINCRBY', KEYS[6], 'fence:' .. ARGV[15], 1)
if token <= previousToken then return {'FENCING_REGRESSION'} end
local attempt = redis.call('HINCRBY', KEYS[1], 'attempt', 1)
local leaseUntil = now + tonumber(ARGV[5])
redis.call('HDEL', KEYS[1], 'errorType')
redis.call('HSET', KEYS[1], 'state', 'RUNNING', 'owner', ARGV[3],
'attemptToken', token, 'startedAt', now, 'leaseUntil', leaseUntil)
redis.call('ZADD', KEYS[2], leaseUntil, ARGV[14] .. ':' .. ARGV[15])
redis.call('ZREM', KEYS[3], ARGV[14] .. ':' .. ARGV[15])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'STARTED', tostring(attempt), tostring(token), tostring(now), tostring(leaseUntil)}
end
if not state then
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'NOT_FOUND'}
end
local time = redis.call('TIME')
local now = time[1] * 1000 + math.floor(time[2] / 1000)
local function finalize(terminalState, resultCode)
redis.call('ZREM', KEYS[2], ARGV[2])
redis.call('ZREM', KEYS[3], ARGV[2])
redis.call('ZREM', KEYS[5], ARGV[2])
if redis.call('HGET', KEYS[4], ARGV[1]) == ARGV[2] then
redis.call('HDEL', KEYS[4], ARGV[1])
local handoffComplete = false
local handoffJobState = redis.call('HGET', KEYS[9], 'state')
local handoffDeletedRevision = tonumber(redis.call('HGET', KEYS[9], 'deletedRevision') or '-1')
for index = 1, 100 do
local nextEntry = redis.call('ZPOPMIN', KEYS[5], 1)
if not nextEntry[1] then
handoffComplete = true
break
end
local nextRunKey = ARGV[18] .. 'run:' .. nextEntry[1]
if redis.call('HGET', nextRunKey, 'state') == 'BLOCKED' then
local nextRevision = tonumber(redis.call('HGET', nextRunKey, 'definitionRevision') or '0')
if handoffJobState == 'DELETED' or nextRevision <= handoffDeletedRevision then
redis.call('HSET', nextRunKey, 'state', 'CANCELLED', 'finishedAt', now,
'resultCode', 'JOB_DELETED')
redis.call('ZREM', KEYS[2], nextEntry[1])
redis.call('ZREM', KEYS[3], nextEntry[1])
redis.call('XADD', KEYS[8], 'MAXLEN', '~', 100000, '*',
'runId', nextEntry[1], 'state', 'CANCELLED', 'resultCode', 'JOB_DELETED')
redis.call('PEXPIRE', nextRunKey, tonumber(ARGV[10]))
else
redis.call('HSET', nextRunKey, 'state', 'QUEUED', 'nextVisibleAt', now)
redis.call('ZADD', KEYS[3], now, nextEntry[1])
handoffComplete = true
break
end
end
end
if not handoffComplete and redis.call('ZCARD', KEYS[5]) > 0 then
redis.call('SADD', ARGV[18] .. 'reaping', ARGV[1])
end
end
if redis.call('HGET', KEYS[1], 'triggerType') == 'FIXED_DELAY'
and redis.call('HGET', KEYS[9], 'state') == 'ENABLED'
and redis.call('HGET', KEYS[9], 'scheduleType') == 'FIXED_DELAY'
and redis.call('HGET', KEYS[1], 'definitionRevision') == redis.call('HGET', KEYS[9], 'definitionRevision') then
local nextFireAt = now + tonumber(redis.call('HGET', KEYS[9], 'intervalMs') or '0')
redis.call('HSET', KEYS[9], 'lastFireAt', redis.call('HGET', KEYS[1], 'logicalFireAt'),
'nextFireAt', nextFireAt)
redis.call('ZADD', KEYS[10], nextFireAt, ARGV[1])
end
redis.call('XADD', KEYS[8], 'MAXLEN', '~', 100000, '*',
'runId', ARGV[2], 'state', terminalState, 'resultCode', resultCode)
redis.call('PEXPIRE', KEYS[1], tonumber(ARGV[10]))
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
end
if state == 'SUCCEEDED' or state == 'FAILED' or state == 'DEAD' or state == 'SKIPPED' or state == 'CANCELLED' then
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
return {'STALE'}
end
if state == 'RUNNING' then
if redis.call('HGET', KEYS[1], 'owner') == ARGV[3] then
if tonumber(redis.call('HGET', KEYS[1], 'leaseUntil') or '0') <= now then
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
return {'LEASE_EXPIRED'}
end
local leaseUntil = now + tonumber(ARGV[5])
redis.call('HSET', KEYS[1], 'leaseUntil', leaseUntil)
redis.call('ZADD', KEYS[2], leaseUntil, ARGV[2])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'ADOPTED', redis.call('HGET', KEYS[1], 'attempt'), redis.call('HGET', KEYS[1], 'attemptToken'), tostring(now), tostring(leaseUntil)}
end
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
return {'STALE'}
end
if state ~= 'QUEUED' then
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
return {'STALE'}
end
local runSource = redis.call('HGET', KEYS[1], 'schedulerQualifier') or ''
local definitionSource = redis.call('HGET', KEYS[9], 'schedulerQualifier') or ''
if runSource ~= ARGV[19] or definitionSource ~= ARGV[19] then
redis.call('HSET', KEYS[1], 'state', 'FAILED', 'errorType', 'SOURCE_MISMATCH',
'resultCode', 'SOURCE_MISMATCH', 'finishedAt', now,
'observedSource', runSource, 'observedDefinitionSource', definitionSource)
finalize('FAILED', 'SOURCE_MISMATCH')
return {'SOURCE_MISMATCH'}
end
local jobState = redis.call('HGET', KEYS[9], 'state')
local deletedRevision = tonumber(redis.call('HGET', KEYS[9], 'deletedRevision') or '-1')
local runRevision = tonumber(redis.call('HGET', KEYS[1], 'definitionRevision') or '0')
if jobState == 'DELETED' or runRevision <= deletedRevision then
redis.call('HSET', KEYS[1], 'state', 'CANCELLED', 'finishedAt', now, 'resultCode', 'JOB_DELETED')
finalize('CANCELLED', 'JOB_DELETED')
return {'JOB_DELETED'}
end
local namespaceState = redis.call('HGET', KEYS[11], 'namespaceState') or 'ENABLED'
if jobState ~= 'ENABLED' or namespaceState ~= 'ENABLED' then
local nextVisibleAt = now + tonumber(ARGV[20])
redis.call('HSET', KEYS[1], 'nextVisibleAt', nextVisibleAt)
redis.call('ZADD', KEYS[3], nextVisibleAt, ARGV[2])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'DEFERRED'}
end
if tonumber(redis.call('HGET', KEYS[1], 'protocolVersion') or '0') > tonumber(ARGV[13]) then
local nextVisibleAt = now + tonumber(ARGV[8])
redis.call('HSET', KEYS[1], 'errorType', 'PROTOCOL_UNSUPPORTED', 'nextVisibleAt', nextVisibleAt)
redis.call('ZADD', KEYS[3], nextVisibleAt, ARGV[2])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'PROTOCOL_UNSUPPORTED'}
end
local storedCodec = redis.call('HGET', KEYS[1], 'wireCodec') or ''
if redis.call('HGET', KEYS[1], 'jobName') ~= ARGV[1]
or redis.call('HGET', KEYS[1], 'definitionRevision') ~= ARGV[14]
or redis.call('HGET', KEYS[1], 'contractRevision') ~= ARGV[15]
or redis.call('HGET', KEYS[1], 'schemaId') ~= ARGV[16]
or not string.find(',' .. ARGV[17] .. ',', ',' .. storedCodec .. ',', 1, true) then
local nextVisibleAt = now + tonumber(ARGV[8])
redis.call('HSET', KEYS[1], 'errorType', 'CONTRACT_MISMATCH', 'nextVisibleAt', nextVisibleAt)
redis.call('ZADD', KEYS[3], nextVisibleAt, ARGV[2])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'CONFLICT'}
end
if redis.call('HGET', KEYS[1], 'cancelRequestedAt') then
redis.call('HSET', KEYS[1], 'state', 'CANCELLED', 'finishedAt', now, 'resultCode', 'CANCELLED')
finalize('CANCELLED', 'CANCELLED')
return {'CANCELLED'}
end
if ARGV[6] ~= 'PARALLEL' then
local occupied = redis.call('HGET', KEYS[4], ARGV[1])
if occupied and occupied ~= ARGV[2] then
if ARGV[6] == 'DISCARD_IF_RUNNING' then
redis.call('HSET', KEYS[1], 'state', 'SKIPPED', 'finishedAt', now, 'resultCode', 'RUNNING_EXISTS')
finalize('SKIPPED', 'RUNNING_EXISTS')
return {'SKIPPED'}
end
if ARGV[6] == 'SERIAL_QUEUE' and redis.call('ZCARD', KEYS[5]) >= tonumber(ARGV[7]) then
if ARGV[12] == 'SKIP_NEWEST' then
redis.call('HSET', KEYS[1], 'state', 'SKIPPED', 'finishedAt', now,
'resultCode', 'SERIAL_BACKLOG_OVERFLOW')
finalize('SKIPPED', 'SERIAL_BACKLOG_OVERFLOW')
return {'SKIPPED'}
end
local oldest = redis.call('ZPOPMIN', KEYS[5], 1)
if oldest[1] then
local oldestKey = ARGV[18] .. 'run:' .. oldest[1]
if redis.call('HGET', oldestKey, 'state') == 'BLOCKED' then
redis.call('HSET', oldestKey, 'state', 'SKIPPED', 'finishedAt', now,
'resultCode', 'SERIAL_BACKLOG_OVERFLOW')
redis.call('ZREM', KEYS[3], oldest[1])
redis.call('ZREM', KEYS[2], oldest[1])
if redis.call('HGET', oldestKey, 'triggerType') == 'FIXED_DELAY'
and redis.call('HGET', KEYS[9], 'state') == 'ENABLED'
and redis.call('HGET', KEYS[9], 'scheduleType') == 'FIXED_DELAY'
and redis.call('HGET', oldestKey, 'definitionRevision') == redis.call('HGET', KEYS[9], 'definitionRevision') then
local oldestNextFireAt = now + tonumber(redis.call('HGET', KEYS[9], 'intervalMs') or '0')
redis.call('HSET', KEYS[9], 'lastFireAt', redis.call('HGET', oldestKey, 'logicalFireAt'),
'nextFireAt', oldestNextFireAt)
redis.call('ZADD', KEYS[10], oldestNextFireAt, ARGV[1])
end
redis.call('XADD', KEYS[8], 'MAXLEN', '~', 100000, '*', 'runId', oldest[1],
'state', 'SKIPPED', 'resultCode', 'SERIAL_BACKLOG_OVERFLOW')
redis.call('PEXPIRE', oldestKey, ARGV[10])
end
end
end
redis.call('HSET', KEYS[1], 'state', 'BLOCKED')
redis.call('ZREM', KEYS[3], ARGV[2])
redis.call('ZADD', KEYS[5], redis.call('HGET', KEYS[1], 'logicalFireAt'), ARGV[2])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'BLOCKED'}
end
end
local previousToken = tonumber(redis.call('HGET', KEYS[1], 'attemptToken')) or 0
local attemptToken = redis.call('HINCRBY', KEYS[6], ARGV[1], 1)
if attemptToken <= previousToken then
local nextVisibleAt = now + tonumber(ARGV[8])
redis.call('HSET', KEYS[1], 'errorType', 'FENCING_REGRESSION', 'nextVisibleAt', nextVisibleAt)
redis.call('ZADD', KEYS[3], nextVisibleAt, ARGV[2])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'FENCING_REGRESSION'}
end
local attempt = redis.call('HINCRBY', KEYS[1], 'attempt', 1)
local leaseUntil = now + tonumber(ARGV[5])
redis.call('HDEL', KEYS[1], 'errorType')
redis.call('HSET', KEYS[1], 'state', 'RUNNING', 'owner', ARGV[3],
'attemptToken', attemptToken, 'startedAt', now, 'leaseUntil', leaseUntil, 'dispatchAttempts', 0)
if ARGV[6] ~= 'PARALLEL' then redis.call('HSET', KEYS[4], ARGV[1], ARGV[2]) end
redis.call('ZADD', KEYS[2], leaseUntil, ARGV[2])
redis.call('ZREM', KEYS[3], ARGV[2])
redis.call('ZREM', KEYS[5], ARGV[2])
redis.call('XACK', KEYS[7], ARGV[9], ARGV[4])
redis.call('XDEL', KEYS[7], ARGV[4])
return {'STARTED', tostring(attempt), tostring(attemptToken), tostring(now), tostring(leaseUntil)}