class TestFinishedJobRegistry(RQTestCase):
def setUp(self):
super(TestFinishedJobRegistry, self).setUp()
self.registry = FinishedJobRegistry(connection=self.testconn)
def test_cleanup(self):
"""Finished job registry removes expired jobs."""
timestamp = current_timestamp()
self.testconn.zadd(self.registry.key, 1, 'foo')
self.testconn.zadd(self.registry.key, timestamp + 10, 'bar')
self.testconn.zadd(self.registry.key, timestamp + 30, 'baz')
self.registry.cleanup()
self.assertEqual(self.registry.get_job_ids(), ['bar', 'baz'])
self.registry.cleanup(timestamp + 20)
self.assertEqual(self.registry.get_job_ids(), ['baz'])
def test_jobs_are_put_in_registry(self):
"""Completed jobs are added to FinishedJobRegistry."""
self.assertEqual(self.registry.get_job_ids(), [])
queue = Queue(connection=self.testconn)
worker = Worker([queue])
# Completed jobs are put in FinishedJobRegistry
job = queue.enqueue(say_hello)
worker.perform_job(job)
self.assertEqual(self.registry.get_job_ids(), [job.id])
# Failed jobs are not put in FinishedJobRegistry
failed_job = queue.enqueue(div_by_zero)
worker.perform_job(failed_job)
self.assertEqual(self.registry.get_job_ids(), [job.id])
def test_finished_jobs(self):
"""Ensure that finished jobs page works properly."""
queue = get_queue('django_rq_test')
queue_index = get_queue_index('django_rq_test')
job = queue.enqueue(access_self)
registry = FinishedJobRegistry(queue.name, queue.connection)
registry.add(job, 2)
response = self.client.get(
reverse('rq_finished_jobs', args=[queue_index])
)
self.assertEqual(response.context['jobs'], [job])
class TestFinishedJobRegistry(RQTestCase):
def setUp(self):
super(TestFinishedJobRegistry, self).setUp()
self.registry = FinishedJobRegistry(connection=self.testconn)
def test_key(self):
self.assertEqual(self.registry.key, 'rq:finished:default')
def test_cleanup(self):
"""Finished job registry removes expired jobs."""
timestamp = current_timestamp()
self.testconn.zadd(self.registry.key, {'foo': 1})
self.testconn.zadd(self.registry.key, {'bar': timestamp + 10})
self.testconn.zadd(self.registry.key, {'baz': timestamp + 30})
self.registry.cleanup()
self.assertEqual(self.registry.get_job_ids(), ['bar', 'baz'])
self.registry.cleanup(timestamp + 20)
self.assertEqual(self.registry.get_job_ids(), ['baz'])
def test_jobs_are_put_in_registry(self):
"""Completed jobs are added to FinishedJobRegistry."""
self.assertEqual(self.registry.get_job_ids(), [])
queue = Queue(connection=self.testconn)
worker = Worker([queue])
# Completed jobs are put in FinishedJobRegistry
job = queue.enqueue(say_hello)
worker.perform_job(job, queue)
self.assertEqual(self.registry.get_job_ids(), [job.id])
# When job is deleted, it should be removed from FinishedJobRegistry
self.assertEqual(job.get_status(), JobStatus.FINISHED)
job.delete()
self.assertEqual(self.registry.get_job_ids(), [])
# Failed jobs are not put in FinishedJobRegistry
failed_job = queue.enqueue(div_by_zero)
worker.perform_job(failed_job, queue)
self.assertEqual(self.registry.get_job_ids(), [])
def test_getting_registries(self):
"""Getting job registries from queue object"""
queue = Queue('example')
self.assertEqual(queue.scheduled_job_registry,
ScheduledJobRegistry(queue=queue))
self.assertEqual(queue.started_job_registry,
StartedJobRegistry(queue=queue))
self.assertEqual(queue.failed_job_registry,
FailedJobRegistry(queue=queue))
self.assertEqual(queue.deferred_job_registry,
DeferredJobRegistry(queue=queue))
self.assertEqual(queue.finished_job_registry,
FinishedJobRegistry(queue=queue))
def get_all_jobs(connection=None, queue_name=DEFAULT_QUEUE_NAME):
from redis import Redis
from rq import Queue
from rq.job import Job
from rq.registry import FinishedJobRegistry, FailedJobRegistry
queue = Queue(queue_name, connection=connection or Redis())
queued_jobs = queue.job_ids
finished_jobs = FinishedJobRegistry(queue=queue).get_job_ids()
failed_jobs = FailedJobRegistry(queue=queue).get_job_ids()
return Job.fetch_many(
queued_jobs + finished_jobs + failed_jobs, connection=connection
)
def test_work_with_ssl(self):
connection = find_empty_redis_database(ssl=True)
queue = Queue(connection=connection)
worker = Worker(queues=[queue], connection=connection)
p = Process(target=kill_worker, args=(os.getpid(), False, 5))
p.start()
queue.enqueue_at(datetime(2019, 1, 1, tzinfo=timezone.utc), say_hello)
worker.work(burst=False, with_scheduler=True)
p.join(1)
self.assertIsNotNone(worker.scheduler)
registry = FinishedJobRegistry(queue=queue)
self.assertEqual(len(registry), 1)
def connect_redis():
"""
Connect to Redis and store the connection for in the application
context.
"""
g.redis = Redis(host=app.config['REDIS_HOST'],
port=app.config['REDIS_PORT'],
db=app.config['REDIS_DB'])
g.queue = Queue(connection=g.redis)
g.started_registry = StartedJobRegistry(connection=g.redis)
g.finished_registry = FinishedJobRegistry(connection=g.redis)
def test_job_delete_removes_itself_from_registries(self):
"""job.delete() should remove itself from job registries"""
connection = self.testconn
job = Job.create(func=fixtures.say_hello, status=JobStatus.FAILED,
connection=self.testconn, origin='default')
job.save()
registry = FailedJobRegistry(connection=self.testconn)
registry.add(job, 500)
job.delete()
self.assertFalse(job in registry)
job = Job.create(func=fixtures.say_hello, status=JobStatus.FINISHED,
connection=self.testconn, origin='default')
job.save()
registry = FinishedJobRegistry(connection=self.testconn)
registry.add(job, 500)
job.delete()
self.assertFalse(job in registry)
job = Job.create(func=fixtures.say_hello, status=JobStatus.STARTED,
connection=self.testconn, origin='default')
job.save()
registry = StartedJobRegistry(connection=self.testconn)
registry.add(job, 500)
job.delete()
self.assertFalse(job in registry)
job = Job.create(func=fixtures.say_hello, status=JobStatus.DEFERRED,
connection=self.testconn, origin='default')
job.save()
registry = DeferredJobRegistry(connection=self.testconn)
registry.add(job, 500)
job.delete()
self.assertFalse(job in registry)
job = Job.create(func=fixtures.say_hello, status=JobStatus.SCHEDULED,
connection=self.testconn, origin='default')
job.save()
registry = ScheduledJobRegistry(connection=self.testconn)
registry.add(job, 500)
job.delete()
self.assertFalse(job in registry)
def info(request, token):
"""
Return the HireFire json data needed to scale worker dynos
"""
if not settings.HIREFIRE_TOKEN:
return HttpResponseBadRequest(
"Hirefire not configured. Set the HIREFIRE_TOKEN environment variable on the app to use Hirefire for dyno scaling"
)
if token != settings.HIREFIRE_TOKEN:
raise PermissionDenied("Invalid token")
current_tasks = 0
queues = []
for index, config in enumerate(QUEUES_LIST):
queue = get_queue_by_index(index)
connection = queue.connection
# Only look at the default queue
if queue.name != "default":
continue
queue_data = {
"name": queue.name,
"jobs": queue.count,
"index": index,
"connection_kwargs": connection.connection_pool.connection_kwargs,
}
connection = get_connection(queue.name)
all_workers = Worker.all(connection=connection)
queue_workers = [worker for worker in all_workers if queue in worker.queues]
queue_data["workers"] = len(queue_workers)
finished_job_registry = FinishedJobRegistry(queue.name, connection)
started_job_registry = StartedJobRegistry(queue.name, connection)
deferred_job_registry = DeferredJobRegistry(queue.name, connection)
queue_data["finished_jobs"] = len(finished_job_registry)
queue_data["started_jobs"] = len(started_job_registry)
queue_data["deferred_jobs"] = len(deferred_job_registry)
current_tasks += queue_data["jobs"]
current_tasks += queue_data["started_jobs"]
queues.append(queue_data)
payload = [{"quantity": current_tasks, "name": "worker"}]
payload = json.dumps(payload)
return HttpResponse(payload, content_type="application/json")
def serialize_queues(instance_number, queues):
return [
dict(
name=q.name,
count=q.count,
queued_url=url_for(
".jobs_overview",
instance_number=instance_number,
queue_name=q.name,
registry_name="queued",
per_page="8",
page="1",
),
failed_job_registry_count=FailedJobRegistry(q.name).count,
failed_url=url_for(
".jobs_overview",
instance_number=instance_number,
queue_name=q.name,
registry_name="failed",
per_page="8",
page="1",
),
started_job_registry_count=StartedJobRegistry(q.name).count,
started_url=url_for(
".jobs_overview",
instance_number=instance_number,
queue_name=q.name,
registry_name="started",
per_page="8",
page="1",
),
deferred_job_registry_count=DeferredJobRegistry(q.name).count,
deferred_url=url_for(
".jobs_overview",
instance_number=instance_number,
queue_name=q.name,
registry_name="deferred",
per_page="8",
page="1",
),
finished_job_registry_count=FinishedJobRegistry(q.name).count,
finished_url=url_for(
".jobs_overview",
instance_number=instance_number,
queue_name=q.name,
registry_name="finished",
per_page="8",
page="1",
),
) for q in queues
]
def get_statistics(run_maintenance_tasks=False):
queues = []
for index, config in enumerate(QUEUES_LIST):
queue = get_queue_by_index(index)
connection = queue.connection
connection_kwargs = connection.connection_pool.connection_kwargs
if run_maintenance_tasks:
clean_registries(queue)
clean_worker_registry(queue)
# Raw access to the first item from left of the redis list.
# This might not be accurate since new job can be added from the left
# with `at_front` parameters.
# Ideally rq should supports Queue.oldest_job
last_job_id = connection.lindex(queue.key, 0)
last_job = queue.fetch_job(
last_job_id.decode('utf-8')) if last_job_id else None
if last_job:
oldest_job_timestamp = to_localtime(last_job.enqueued_at)\
.strftime('%Y-%m-%d, %H:%M:%S')
else:
oldest_job_timestamp = "-"
# parse_class and connection_pool are not needed and not JSON serializable
connection_kwargs.pop('parser_class', None)
connection_kwargs.pop('connection_pool', None)
queue_data = {
'name': queue.name,
'jobs': queue.count,
'oldest_job_timestamp': oldest_job_timestamp,
'index': index,
'connection_kwargs': connection_kwargs
}
connection = get_connection(queue.name)
queue_data['workers'] = Worker.count(queue=queue)
finished_job_registry = FinishedJobRegistry(queue.name, connection)
started_job_registry = StartedJobRegistry(queue.name, connection)
deferred_job_registry = DeferredJobRegistry(queue.name, connection)
failed_job_registry = FailedJobRegistry(queue.name, connection)
queue_data['finished_jobs'] = len(finished_job_registry)
queue_data['started_jobs'] = len(started_job_registry)
queue_data['deferred_jobs'] = len(deferred_job_registry)
queue_data['failed_jobs'] = len(failed_job_registry)
queues.append(queue_data)
return {'queues': queues}
def finished_jobs(request, queue_index):
queue_index = int(queue_index)
queue = get_queue_by_index(queue_index)
registry = FinishedJobRegistry(queue.name, queue.connection)
items_per_page = 100
num_jobs = len(registry)
page = int(request.GET.get('page', 1))
jobs = []
if num_jobs > 0:
last_page = int(ceil(num_jobs / items_per_page))
page_range = range(1, last_page + 1)
offset = items_per_page * (page - 1)
job_ids = registry.get_job_ids(offset, items_per_page)
for job_id in job_ids:
try:
jobs.append(Job.fetch(job_id, connection=queue.connection))
except NoSuchJobError:
pass
else:
page_range = []
context_data = admin.site.each_context(request)
context_data.update({
'title': _("Finished Jobs"),
'queue': queue,
'queue_index': queue_index,
'jobs': jobs,
'num_jobs': num_jobs,
'page': page,
'page_range': page_range,
'job_status': _('Finished'),
})
return render(request, 'django_rq/jobs.html', context_data)
def jobs():
with Connection(redis_client):
q = Queue()
# possibly also use DeferredJobRegistry()
jobs = OrderedDict([
(name, [q.fetch_job(job_id) for job_id in registry.get_job_ids()])
for (name,
registry) in [('Waiting', q), (
'Running',
StartedJobRegistry()), (
'Finished',
FinishedJobRegistry()), ('Failed', Queue('failed'))]
])
return render_template('jobs.html', jobs=jobs)
def test_clean_registries(self):
"""clean_registries() cleans Started and Finished job registries."""
queue = Queue(connection=self.testconn)
finished_job_registry = FinishedJobRegistry(connection=self.testconn)
self.testconn.zadd(finished_job_registry.key, 1, 'foo')
started_job_registry = StartedJobRegistry(connection=self.testconn)
self.testconn.zadd(started_job_registry.key, 1, 'foo')
clean_registries(queue)
self.assertEqual(self.testconn.zcard(finished_job_registry.key), 0)
self.assertEqual(self.testconn.zcard(started_job_registry.key), 0)
def status_by_map(map_id, version, file_type):
""" Retrieve status of a render job by it `map_id`, `verison` and
`file_type`
:param map_id: map id
:param version: version
:param file_type: filetype
:status 200: informations about current job
:status 400: invalid file type
:status 404: map and or version of map not found
"""
queue = current_app.task_queue
# check if it is queued to be rendered
for job in queue.get_jobs():
if job.meta['map_id'] == map_id and\
job.meta['version'] == version and\
job.meta['file_type'] == file_type:
return status_by_job(job)
# check if it is currently rendering
started = StartedJobRegistry(queue=queue)
job = _find_in_registry(started, map_id, version, file_type)
if job:
return status_by_job(job)
# it it's not queued or rendering, it needs to be already rendered
try:
file_info = get_file_info(map_id, version, file_type)
if not file_exists(file_info):
abort(404)
except UnsupportedFileType:
abort(400)
# enhance output with job_id if it is recently rendered
finished = FinishedJobRegistry(queue=queue)
job = _find_in_registry(finished, map_id, version, file_type)
if job:
return status_by_job(job)
data = {
'map_id': map_id,
'file_type': file_type,
'version': version,
'status': 'finished',
'url': url_for('static', filename=file_info['path'], _external=True)
}
return jsonify(**data)
def finished_jobs(request, queue_index):
queue_index = int(queue_index)
queue = get_queue_by_index(queue_index)
registry = FinishedJobRegistry(queue.name, queue.connection)
items_per_page = 100
num_jobs = len(registry)
page = int(request.GET.get('page', 1))
jobs = []
if num_jobs > 0:
last_page = int(ceil(num_jobs / items_per_page))
page_range = range(1, last_page + 1)
offset = items_per_page * (page - 1)
job_ids = registry.get_job_ids(offset, offset + items_per_page - 1)
for job_id in job_ids:
try:
jobs.append(Job.fetch(job_id, connection=queue.connection))
except NoSuchJobError:
pass
else:
page_range = []
context_data = {
'queue': queue,
'queue_index': queue_index,
'jobs': jobs,
'num_jobs': num_jobs,
'page': page,
'page_range': page_range,
'job_status': 'Finished',
}
return render(request, 'django_rq/jobs.html', context_data)
def get_finished_tasks(request):
current_queue = request.GET.get('queue')
queue = django_rq.get_queue(current_queue)
registry = FinishedJobRegistry(queue.name, queue.connection)
items_per_page = 10
num_jobs = len(registry)
jobs = []
if num_jobs > 0:
offset = 0
job_ids = registry.get_job_ids(offset, items_per_page)
for job_id in job_ids:
try:
jobs.append(Job.fetch(job_id, connection=queue.connection))
except NoSuchJobError:
pass
jobdata = list()
for job in jobs:
job_dict = {
'job_id': job.id,
'func_name': job.func_name,
'ended_at': job.ended_at.strftime("%a, %d %b %Y %H:%M:%S +0000"),
'enqueued_at':
job.enqueued_at.strftime("%a, %d %b %Y %H:%M:%S +0000"),
'args': [str(arg) for arg in job.args]
}
jobdata.append(job_dict)
data = json.dumps(jobdata)
return HttpResponse(data, content_type='application/json')
def monitor():
'''
DOESN'T WORK
Meant to run until all jobs are finished. Monitors queues and adds completed graphs to Blazegraph.
'''
sregistry = StartedJobRegistry(connection=redis_conn)
fregistry = FinishedJobRegistry(connection=redis_conn)
print high.get_job_ids()
print sregistry.get_job_ids()
while sregistry.get_job_ids():
print 'in sregistry...'
print fregistry.get_job_ids()
for job_id in fregistry.get_job_ids():
job = Job.fetch(job_id, connection=redis_conn)
# sanity check
if type(job.result) is Graph:
print ('inserting', job_id, job)
logging.info('inserting', job_id, job)
insert(job.result)
print 'sleeping 5'
time.sleep(5)
print 'all jobs complete'
logging.info('monitor() exiting...all jobs complete')
def test_work_with_serializer(self):
queue = Queue(connection=self.testconn, serializer=JSONSerializer)
worker = Worker(queues=[queue],
connection=self.testconn,
serializer=JSONSerializer)
p = Process(target=kill_worker, args=(os.getpid(), False, 5))
p.start()
queue.enqueue_at(datetime(2019, 1, 1, tzinfo=timezone.utc),
say_hello,
meta={'foo': 'bar'})
worker.work(burst=False, with_scheduler=True)
p.join(1)
self.assertIsNotNone(worker.scheduler)
registry = FinishedJobRegistry(queue=queue)
self.assertEqual(len(registry), 1)
def get(self):
logging.debug("Get query params")
parser = reqparse.RequestParser()
parser.add_argument('id', required=True, type=str)
parser.add_argument('check', required=True, type=str)
args = parser.parse_args()
id = args['id']
check = args['check']
ts = int(time.time())
logging.debug("Get query all jobs")
try:
registry = FinishedJobRegistry('default', connection=redis)
job_ids = registry.get_job_ids()
tsarr = []
tmparr = []
for i in job_ids:
logging.debug("Get job id " + i)
joba = q.fetch_job(i)
try:
logging.debug("Check job for conditions " + i + " id=" +
joba.meta['id'] + " check=" +
joba.meta['check'] + " ts=" +
joba.meta['ts'])
if joba.meta['id'] == id and joba.meta['check'] == check:
logging.debug("Find job for id=" + joba.meta['id'] +
" check=" + joba.meta['check'] + " ts=" +
joba.meta['ts'])
tsarr.append(int(joba.meta['ts']))
tmparr.append({"job": i, "ts": str(joba.meta['ts'])})
except:
pass
if tsarr:
logging.debug("Find max time ")
logging.debug("For array job " + str(tmparr))
max_time = max(tsarr)
logging.debug("Max time " + str(max_time))
for j in tmparr:
if int(j['ts']) == max_time:
job_max_id = j['job']
logging.debug("Max time job " + str(job_max_id))
job_m = q.fetch_job(job_max_id)
headers = {'Content-Type': 'application/json'}
data = job_m.result
return make_response(data, 200, headers)
except Exception as e:
print(str(e))
return "Not found", 404
def get_meta_info(app_info):
with Connection(redis.from_url(app_info['REDIS_URL'])):
q = Queue('default')
registry = StartedJobRegistry('default')
f_registry = FinishedJobRegistry('default')
# Retrieve task ids
all_task_ids = get_all_task_ids(app_info)
task_data = {
'queue': q,
'task_ids': all_task_ids,
}
data = {}
data['running_tasks'] = fetch_tasks_by_category(task_data, "running")
data['queued_tasks'] = fetch_tasks_by_category(task_data, "queued")
data['finished_tasks'] = fetch_tasks_by_category(task_data, "finished")
with Connection(redis.from_url(app_info['REDIS_URL'])):
q = Queue('aggregator')
# Get all aggregated finished tasks
task_data = {
'queue': q,
'task_ids': get_all_finished_tasks_from('aggregator', app_info),
}
data['agg_finished_tasks'] = fetch_tasks_by_category(
task_data, "finished")
# Get all aggregated queued tasks
task_data = {
'queue': q,
'task_ids': get_all_queued_tasks_from('aggregator', app_info),
}
data['agg_queued_tasks'] = fetch_tasks_by_category(task_data, "queued")
# Get all aggregated running tasks
task_data = {
'queue': q,
'task_ids': get_all_running_tasks_from('aggregator', app_info),
}
data['agg_running_tasks'] = fetch_tasks_by_category(
task_data, "running")
return data
class TestFinishedJobRegistry(RQTestCase):
def setUp(self):
super(TestFinishedJobRegistry, self).setUp()
self.registry = FinishedJobRegistry(connection=self.testconn)
def test_key(self):
self.assertEqual(self.registry.key, 'rq:finished:default')
def test_cleanup(self):
"""Finished job registry removes expired jobs."""
timestamp = current_timestamp()
self.testconn.zadd(self.registry.key, 1, 'foo')
self.testconn.zadd(self.registry.key, timestamp + 10, 'bar')
self.testconn.zadd(self.registry.key, timestamp + 30, 'baz')
self.registry.cleanup()
self.assertEqual(self.registry.get_job_ids(), ['bar', 'baz'])
self.registry.cleanup(timestamp + 20)
self.assertEqual(self.registry.get_job_ids(), ['baz'])
def test_jobs_are_put_in_registry(self):
"""Completed jobs are added to FinishedJobRegistry."""
self.assertEqual(self.registry.get_job_ids(), [])
queue = Queue(connection=self.testconn)
worker = Worker([queue])
# Completed jobs are put in FinishedJobRegistry
job = queue.enqueue(say_hello)
worker.perform_job(job, queue)
self.assertEqual(self.registry.get_job_ids(), [job.id])
# Failed jobs are not put in FinishedJobRegistry
failed_job = queue.enqueue(div_by_zero)
worker.perform_job(failed_job, queue)
self.assertEqual(self.registry.get_job_ids(), [job.id])
def test_pass_queue_via_commandline_args(self):
"""
Checks that passing queues via commandline arguments works
"""
queue_names = ['django_rq_test', 'django_rq_test2']
jobs = []
for queue_name in queue_names:
queue = get_queue(queue_name)
jobs.append({
'job': queue.enqueue(divide, 42, 1),
'finished_job_registry': FinishedJobRegistry(queue.name, queue.connection),
})
call_command('rqworker', *queue_names, burst=True)
for job in jobs:
self.assertTrue(job['job'].is_finished)
self.assertIn(job['job'].id, job['finished_job_registry'].get_job_ids())
def check_upload_queue():
# Failed jobs
for id in failed_jobs_by_queue(UploadQueue):
update_status(id, "Upload", "Upload", 0, 0)
if os.path.exists(run_folder + str(id)):
shutil.rmtree(run_folder + str(id))
try:
Job.fetch(str(id), connection=redisClient).delete()
except:
return
# Finished jobs
for id in FinishedJobRegistry('UploadQueue',
connection=redisClient).get_job_ids():
if os.path.exists(run_folder + str(id)):
shutil.rmtree(run_folder + str(id))
try:
Job.fetch(str(id), connection=redisClient).delete()
except:
return
def task():
startedjr = StartedJobRegistry("default", connection=redis_conn)
finishedjr = FinishedJobRegistry("default", connection=redis_conn)
failedjr = FailedJobRegistry("default", connection=redis_conn)
deferredjr = DeferredJobRegistry("defaut", connection=redis_conn)
def job_registry_to_json(jr):
return {
"job_ids": jr.get_job_ids(),
"expired_job_ids": jr.get_expired_job_ids(),
}
return json.dumps({
"queued": q.job_ids,
"started": job_registry_to_json(startedjr),
"finished": job_registry_to_json(finishedjr),
"failed": job_registry_to_json(failedjr),
"deferred": job_registry_to_json(deferredjr)
})
def get_queue_registry_jobs_count(queue_name, registry_name, offset, per_page):
queue = Queue(queue_name)
if registry_name == 'failed':
current_queue = FailedJobRegistry(queue_name)
elif registry_name == 'deferred':
current_queue = DeferredJobRegistry(queue_name)
elif registry_name == 'started':
current_queue = StartedJobRegistry(queue_name)
elif registry_name == 'finished':
current_queue = FinishedJobRegistry(queue_name)
else:
current_queue = queue
total_items = current_queue.count
job_ids = current_queue.get_job_ids(offset, per_page)
current_queue_jobs = [queue.fetch_job(job_id) for job_id in job_ids]
jobs = [serialize_job(job) for job in current_queue_jobs]
return (total_items, jobs)
def stats(request):
queues = []
for index, config in enumerate(QUEUES_LIST):
queue = get_queue_by_index(index)
connection = queue.connection
queue_data = {
'name': queue.name,
'jobs': queue.count,
'index': index,
'connection_kwargs': connection.connection_pool.connection_kwargs
}
if queue.name == 'failed':
queue_data['workers'] = '-'
queue_data['finished_jobs'] = '-'
queue_data['started_jobs'] = '-'
queue_data['deferred_jobs'] = '-'
else:
connection = get_connection(queue.name)
all_workers = Worker.all(connection=connection)
queue_workers = [worker for worker in all_workers if queue in worker.queues]
queue_data['workers'] = len(queue_workers)
finished_job_registry = FinishedJobRegistry(queue.name, connection)
started_job_registry = StartedJobRegistry(queue.name, connection)
deferred_job_registry = DeferredJobRegistry(queue.name, connection)
queue_data['finished_jobs'] = len(finished_job_registry)
queue_data['started_jobs'] = len(started_job_registry)
queue_data['deferred_jobs'] = len(deferred_job_registry)
queues.append(queue_data)
context_data = admin.site.each_context(request)
context_data.update({
'title': _('Django RQ'),
'queues': queues
})
return render(request, 'django_rq/stats.html', context_data)
def stats(request):
queues = []
workers_collections = collect_workers_by_connection(QUEUES_LIST)
for index, config in enumerate(QUEUES_LIST):
queue = get_queue_by_index(index)
connection = queue.connection
queue_data = {
'name': queue.name,
'jobs': queue.count,
'index': index,
'connection_kwargs': connection.connection_pool.connection_kwargs
}
if queue.name == 'failed':
queue_data['workers'] = '-'
queue_data['finished_jobs'] = '-'
queue_data['started_jobs'] = '-'
queue_data['deferred_jobs'] = '-'
else:
connection = get_connection(queue.name)
all_workers = get_all_workers_by_configuration(
config['connection_config'], workers_collections)
queue_workers = [
worker for worker in all_workers if queue in worker.queues
]
queue_data['workers'] = len(queue_workers)
finished_job_registry = FinishedJobRegistry(queue.name, connection)
started_job_registry = StartedJobRegistry(queue.name, connection)
deferred_job_registry = DeferredJobRegistry(queue.name, connection)
queue_data['finished_jobs'] = len(finished_job_registry)
queue_data['started_jobs'] = len(started_job_registry)
queue_data['deferred_jobs'] = len(deferred_job_registry)
queues.append(queue_data)
context_data = {'queues': queues}
return render(request, 'django_rq/stats.html', context_data)
def empty_queue(queue_name, registry_name):
if registry_name == "queued":
q = Queue(queue_name)
q.empty()
elif registry_name == "failed":
ids = FailedJobRegistry(queue_name).get_job_ids()
for id in ids:
delete_job_view(id)
elif registry_name == "deferred":
ids = DeferredJobRegistry(queue_name).get_job_ids()
for id in ids:
delete_job_view(id)
elif registry_name == "started":
ids = StartedJobRegistry(queue_name).get_job_ids()
for id in ids:
delete_job_view(id)
elif registry_name == "finished":
ids = FinishedJobRegistry(queue_name).get_job_ids()
for id in ids:
delete_job_view(id)
return dict(status="OK")
def test_clean_registries_with_serializer(self):
"""clean_registries() cleans Started and Finished job registries (with serializer)."""
queue = Queue(connection=self.testconn, serializer=JSONSerializer)
finished_job_registry = FinishedJobRegistry(connection=self.testconn,
serializer=JSONSerializer)
self.testconn.zadd(finished_job_registry.key, {'foo': 1})
started_job_registry = StartedJobRegistry(connection=self.testconn,
serializer=JSONSerializer)
self.testconn.zadd(started_job_registry.key, {'foo': 1})
failed_job_registry = FailedJobRegistry(connection=self.testconn,
serializer=JSONSerializer)
self.testconn.zadd(failed_job_registry.key, {'foo': 1})
clean_registries(queue)
self.assertEqual(self.testconn.zcard(finished_job_registry.key), 0)
self.assertEqual(self.testconn.zcard(started_job_registry.key), 0)
self.assertEqual(self.testconn.zcard(failed_job_registry.key), 0)
def is_training(cls, project):
if not cls.has_active_model(project):
return {'is_training': False}
m = cls.get(project)
if cls.without_redis():
return {
'is_training': m.is_training,
'backend': 'none',
'model_version': m.model_version
}
else:
started_jobs = StartedJobRegistry(
cls._redis_queue.name,
cls._redis_queue.connection).get_job_ids()
finished_jobs = FinishedJobRegistry(
cls._redis_queue.name,
cls._redis_queue.connection).get_job_ids()
failed_jobs = FailedJobRegistry(
cls._redis_queue.name,
cls._redis_queue.connection).get_job_ids()
running_jobs = list(
set(started_jobs) - set(finished_jobs + failed_jobs))
logger.debug('Running jobs: ' + str(running_jobs))
for job_id in running_jobs:
job = Job.fetch(job_id, connection=cls._redis)
if job.meta.get('project') == project:
return {
'is_training': True,
'job_id': job_id,
'backend': 'redis',
'model_version': m.model_version,
}
return {
'is_training': False,
'backend': 'redis',
'model_version': m.model_version
}
def is_training(cls, project):
if not cls.has_active_model(project):
return {"is_training": False}
m = cls.get(project)
if cls.without_redis():
return {
"is_training": m.is_training,
"backend": "none",
"model_version": m.model_version,
}
else:
started_jobs = StartedJobRegistry(
cls._redis_queue.name, cls._redis_queue.connection
).get_job_ids()
finished_jobs = FinishedJobRegistry(
cls._redis_queue.name, cls._redis_queue.connection
).get_job_ids()
failed_jobs = FailedJobRegistry(
cls._redis_queue.name, cls._redis_queue.connection
).get_job_ids()
running_jobs = list(set(started_jobs) - set(finished_jobs + failed_jobs))
logger.debug("Running jobs: " + str(running_jobs))
for job_id in running_jobs:
job = Job.fetch(job_id, connection=cls._redis)
if job.meta.get("project") == project:
return {
"is_training": True,
"job_id": job_id,
"backend": "redis",
"model_version": m.model_version,
}
return {
"is_training": False,
"backend": "redis",
"model_version": m.model_version,
}
def test_timer_death_penalty(self):
"""Ensure TimerDeathPenalty works correctly."""
q = Queue(connection=self.testconn)
q.empty()
finished_job_registry = FinishedJobRegistry(connection=self.testconn)
failed_job_registry = FailedJobRegistry(connection=self.testconn)
# make sure death_penalty_class persists
w = TimerBasedWorker([q], connection=self.testconn)
self.assertIsNotNone(w)
self.assertEqual(w.death_penalty_class, TimerDeathPenalty)
# Test short-running job doesn't raise JobTimeoutException
job = q.enqueue(thread_friendly_sleep_func, args=(1,), job_timeout=3)
w.work(burst=True)
job.refresh()
self.assertIn(job, finished_job_registry)
# Test long-running job raises JobTimeoutException
job = q.enqueue(thread_friendly_sleep_func, args=(5,), job_timeout=3)
w.work(burst=True)
self.assertIn(job, failed_job_registry)
job.refresh()
self.assertIn("rq.timeouts.JobTimeoutException", job.exc_info)
def finished_job_registry(self):
"""Returns this queue's FinishedJobRegistry."""
from rq.registry import FinishedJobRegistry
return FinishedJobRegistry(queue=self)
def setUp(self):
super(TestFinishedJobRegistry, self).setUp()
self.registry = FinishedJobRegistry(connection=self.testconn)
