def taskstatus_clustal_celery(request, task_id):
if request.method == 'GET':
# print("entering the function taskstatus")
task = current_app.AsyncResult(task_id)
# print("taskStatus", newlines)
context = {
'task_status': task.status,
'task_id': task.id,
'task': task
}
# t = [(1, 400, 400), (401, 800, 600),
# (801, 1200, 700), (1201, 1400, 800), (1401, 1600, 900), (1401, 1600, 1000), (1601, 1800, 1100), (1801, 2000, 1200), (2001, 2200, 1300), (2201, 2400, 1400), (2401, 2600, 1500)]
# radius = 0
# print(radius)
# for i in t:
# if i[0] <= newlines <= i[1]:
# radius = i[2]
# break
if task.status == 'SUCCESS':
context['file'], created = StoreResultFiles.objects.get_or_create(
taskid=task.id, tempfile=task.get())
# context['file'] = StoreResultFiles.objects.filter(taskid=task.id)
# context['align'] = task.get()
return render(request, 'clustalanalysis/dendogram.html', context)
elif task.status == 'PENDING':
# context['results'] = task
return render(request, 'clustalanalysis/dendogram.html', context)
else:
return render(request, 'clustalanalysis/dendogram.html', context)
else:
return render(request, 'clustalanalysis/dendogram.html', context)
def update_tasks_status_in_db():
"""Update all not successful Celery queue tasks statuses in ScrapedURL db table"""
scraped_urls_to_update = ScrapedUrl.objects.exclude(
status=CeleryStatuses.SUCCESS)
for scraped_url in scraped_urls_to_update:
scraped_url.status = current_app.AsyncResult(scraped_url.queue).status
scraped_url.save()
def on_task_prerun(sender=None,
task_id=None,
task=None,
args=None,
kwargs=None,
**_kwargs):
# sender=task, same as the third argument "task"
print('on_task_prerun')
# create work directory
wdir = sender.work_directory
if not os.path.exists(wdir) or not os.path.isdir(wdir):
os.makedirs(wdir)
# check prestate
task_id = sender.request.id
task_result = current_app.AsyncResult(task_id)
prestate = get_prestate(sender._session, task_id)
# revoke canceled task
if prestate == TaskPrestate.CANCELED:
print('cancel')
if os.path.isdir(wdir):
shutil.rmtree(wdir)
task_result.revoke(terminate=True, signal='SIGKILL')
def celery_task_status_clustal(request, task_id):
# print("entering the function taskstatus")
task = current_app.AsyncResult(task_id)
# print("taskStatus", task)
context = {'task_status': task.status, 'task_id': task.id}
return JsonResponse(context)
def mount_failed(task_uuid,
driverCls,
provider,
identity,
volume_id,
unmount=False,
**celery_task_args):
from service import volume as volume_service
try:
celery_logger.debug("mount_failed task started at %s." %
datetime.now())
celery_logger.info("task_uuid=%s" % task_uuid)
result = app.AsyncResult(task_uuid)
with allow_join_result():
exc = result.get(propagate=False)
err_str = "Mount Error Traceback:%s" % (result.traceback, )
celery_logger.error(err_str)
driver = get_driver(driverCls, provider, identity)
volume = driver.get_volume(volume_id)
if unmount:
tmp_status = 'umount_error'
else:
tmp_status = 'mount_error'
return volume_service._update_volume_metadata(
driver, volume, metadata={'tmp_status': tmp_status})
celery_logger.debug("mount_failed task finished at %s." %
datetime.now())
except Exception as exc:
celery_logger.warn(exc)
mount_failed.retry(exc=exc)
def check_result(request, task_id):
task = current_app.AsyncResult(task_id)
response_data = {'task_status': task.status, 'task_id': task.id}
if task.status == 'SUCCESS':
response_data['results'] = task.get()
# print(type(response_data['results']['archive_path']))
return JsonResponse(response_data)
def get(self, request, username, task_id):
task = current_app.AsyncResult(task_id)
response_data = {'task_status': task.status, 'task_id': task.id}
response_data['radii'] = task.result['radii']
response_data['prot_name'] = task.result['prot_name']
response_data['username'] = username
response_data['app'] = 'Network Graph'
proteins, metrics, radii = [], [], []
import os
from django.conf import settings
for netfile in os.listdir(
os.path.join(settings.USER_DATA, username, task_id, '.')):
if netfile.endswith('network.json'):
prot, metric, radius, _ = netfile.split('__')
if prot not in proteins:
proteins.append(prot)
if metric not in metrics:
metrics.append(metric)
if radius not in radii:
radii.append(radius)
netfiles = {'proteins': proteins, 'metrics': metrics, 'radii': radii}
response_data['netfiles'] = netfiles
if task.status == 'SUCCESS':
return render(request, "results/network.html", response_data)
return JsonResponse(response_data)
def get(self, request, task_id):
task = current_app.AsyncResult(task_id)
response_data = {'task_status': task.status, 'task_id': task.id}
if task.status == 'SUCCESS':
response_data['results'] = task.get()
return JsonResponse(response_data)
def taskstatus_needle_celery(request, task_id):
if request.method == "GET":
print("entering the function taskstatus")
task = current_app.AsyncResult(task_id)
print("taskStatus", task)
context = {
"task_status": task.status,
"task_id": task.id,
"task": task,
}
if task.status == "SUCCESS":
context["align"] = task.get()
print(context)
return render(request, "newwebpage/needle.html", context)
elif task.status == "PENDING":
context["results"] = task
return render(request, "newwebpage/needle_processing.html",
context)
context["error"] = task
# print(task)
return render(request, "newwebpage/needle_processing.html", context)
def celery_task_status(request, task_id):
print("entering the function taskstatus")
task = current_app.AsyncResult(task_id)
print("taskStatus", task)
context = {"task_status": task.status, "task_id": task.id}
return JsonResponse(context)
def get(self, request, task_id):
task = current_app.AsyncResult(task_id)
response = {'task_status': task.status}
if task.status == 'SUCCESS':
response['path_to_img'] = task.get()
return JsonResponse(response)
def get(self, request):
task_id = request.query_params.get('task')
ctx = {}
task = current_app.AsyncResult(task_id)
ctx['status'] = task.status # SUCCESS, FAILURE
return Response(ctx)
def get(self, request, username, task_id):
task = current_app.AsyncResult(task_id)
response_data = {'task_status': task.status, 'task_id': task.id}
if task.status == 'SUCCESS':
return density(request, task.id, username)
return JsonResponse(response_data)
def get(self, request, task_id):
task = current_app.AsyncResult(task_id)
response_data = {'task_id': task_id, 'status': task.status, 'result': ''}
if task.status == 'SUCCESS':
response_data['result'] = task.get()
response_data = self.wrap_json_response(data=response_data)
return JsonResponse(data=response_data, safe=False)
def wrapped(task_uuid, *args, **kwargs):
func(*args, **kwargs)
result = current_app.AsyncResult(task_uuid)
transition_entity = kwargs['transition_entity']
message = result.result['exc_message']
if message:
transition_entity.error_message = message
transition_entity.save(update_fields=['error_message'])
def sync_service_log_error(task_uuid, service_uuid):
result = current_app.AsyncResult(task_uuid)
cloud = Cloud.objects.get(uuid=service_uuid)
logger.error('Cloud service %s has failed to sync with error: %s.',
cloud.name, result.result)
event_logger.cloud.error('Cloud service {cloud_name} has failed to sync.',
event_type='iaas_service_sync_failed',
event_context={'cloud': cloud})
sync_service_failed.delay(service_uuid)
def get_status(request):
task_id = request.GET.get('image_task_id')
task = current_app.AsyncResult(task_id)
response_data = {'task_status': task.status, 'task_id': task.id}
if task.status == 'SUCCESS':
response_data['results'] = task.get()
return JsonResponse(response_data)
def status_view(request):
task_id = request.GET['task_id']
# status = 'done'
task = current_app.AsyncResult(task_id)
status = task.status
# status = None
context = {"status": status, "task_id": task_id}
return render(request, "snakes/status.html", context)
def update_one_task_status_in_db(pk):
"""Update one Celery queue task status in ScrapedURL table as 'status' attribute based on pk."""
try:
scraped_url = ScrapedUrl.objects.exclude(
status=CeleryStatuses.SUCCESS).get(pk=pk)
except ObjectDoesNotExist:
return
scraped_url.status = current_app.AsyncResult(scraped_url.queue).status
scraped_url.save()
def get_context_data(self, *args, **kwargs):
context = super(TaskView, self).get_context_data(*args, **kwargs)
task_id = context['pk']
task = current_app.AsyncResult(task_id)
context['task_status'] = task.status
context['task_id'] = task_id
if task.status == 'SUCCESS':
context['result'] = task.get()
return context
def getResult(request, task_id):
if request.method == "GET": # 如果是以POST的方式才處理
print(task_id)
task = current_app.AsyncResult(task_id)
print("task:{}".format(task))
response_data = {'task_status': task.status, 'task_id': task.id}
if task.status == 'SUCCESS':
result = task.get()
response_data['results'] = result
return JsonResponse(data=response_data, status=200)
def status_view(request):
task_id = request.GET['task_id']
task = current_app.AsyncResult(task_id) # task's data
status = task.status
print('status is !!!!', status)
print('task id is', task_id)
return render(request, 'stocks/status_view.html', {
'task_id': task_id,
'status': status
})
def get(self, request, task_id):
task = current_app.AsyncResult(task_id)
context = {
'task_status': task.status,
'task_id': task.id
}
if task.status == 'SUCCESS':
context['resized_image_path'] = task.get()
if task.status == 'PENDING':
context['task_status'] = 'BEING PROCESSED'
return render(request, 'resizer/check_status.html', context)
def get(self, request, task_id):
task = current_app.AsyncResult(task_id)
response_data = {'task_status': task.status, 'task_id': task.id}
# jeśli zadanie wykonane pomyślnie pobieranie wyników results
# a następnie wywołanie metody get przypisując do wyników jako
# json do żądania http
if task.status == 'SUCCESS':
response_data['results'] = task.get()
return JsonResponse(response_data)
def get(self, request, task_id):
task = current_app.AsyncResult(task_id)
response_data = {
'task_status': task.status,
}
if task.status == 'SUCCESS':
response_data['results'] = task.get()
return Response({"HTML-tags": response_data['results']})
elif task.status == 'FAILURE':
return Response('Task error')
elif task.status == 'STARTED':
return Response('THe task is not finishing')
def run(self, set, body, interval=1, max_retries=None, **kwargs):
if not isinstance(set, TaskSet):
set = TaskSet(set)
r = []
setid = gen_unique_id()
for task in set.tasks:
uuid = gen_unique_id()
task.options.update(task_id=uuid, chord=body)
r.append(current_app.AsyncResult(uuid))
current_app.TaskSetResult(setid, r).save()
self.backend.on_chord_apply(setid, body, interval, max_retries)
return set.apply_async(taskset_id=setid)
def get(self, request, username, task_id):
task = current_app.AsyncResult(task_id)
response_data = {'task_status': task.status, 'task_id': task.id}
response_data["prot_name"] = task.result['prot_name']
response_data["username"] = username
response_data["app"] = 'Thickness & Curvature'
if task.status == 'SUCCESS':
return render(request, "results/thickcurv.html", response_data)
return JsonResponse(response_data)
def stv_tasks(request, task_id):
""" Return result from task """
task = current_app.AsyncResult(task_id)
response_data = {"task_status": task.status, "task_id": task.id}
status = 200
if task.ready():
result = task.get()
response_data = result["response"]
status = result["status"]
# Remove this task
task.forget()
return JsonResponse(response_data, status=status)
def strava_get_sync_progress(task_id, total_count):
if task_id == "00000000-0000-0000-0000-000000000000":
return 'SUCCESS', total_count, total_count
if total_count == -1:
return 'CHECKING FOR NEW ACTIVITIES', 0, -1
try:
res = current_app.AsyncResult(task_id)
pending, success, failure, total = count_finished(res)
if total == total_count:
return 'SUCCESS', success, total
else:
return 'IN PROGRESS', success, total_count
except:
return 'FAILED', 0, 0
def sync_service_log_error(task_uuid, service_uuid):
result = current_app.AsyncResult(task_uuid)
cloud = Cloud.objects.get(uuid=service_uuid)
event_logger.error(
'Cloud service %s has failed to sync with error: %s.',
cloud.name,
result.result,
extra={
'cloud': cloud,
'event_type': 'iaas_service_sync_failed'
},
)
sync_service_failed.delay(service_uuid)
