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)