def delete_task(request,task_id):
result="True"
try:
CITaskService.delete_ci_task(request,task_id)
except Exception as ex:
result=str(ex)
SimpleLogger.exception(ex)
return HttpResponse(result)
def clean_task_history(request,task_id):
result="True"
try:
CITaskService.clean_task_history(request,task_id)
except Exception as ex:
result=str(ex)
SimpleLogger.exception(ex)
return HttpResponse(result)
def save_task_config(request,task_id):
''' index page'''
message="True"
try:
CITaskService.save_task_config(request,task_id)
except Exception as ex:
message=str(ex)
SimpleLogger.exception(ex)
return HttpResponse(message)
def update_property(request,task_id):
result=True
try:
CITaskService.update_property(request,task_id)
except Exception as ex:
result=str(ex)
SimpleLogger.exception(ex)
return HttpResponse(result)
def get(self, request, *args, **kwargs):
tq_id = self.kwargs.get("tq_id", "")
task_history = CITaskHistory.objects.get_by_tqid(int(tq_id))
CITaskHistoryService.save_build_log(tq_id)
CITaskHistoryService.clean_build_history(task_history.id)
CITQService.update_task_queue_status(request)
CITaskService.send_task_enqueue_message()
return Response({"message", "task_done"},
status=status.HTTP_201_CREATED)
def fortesting_build(request, fortesting_id):
fortesting = TestApplication.objects.get(fortesting_id)
webhook = WebHook.objects.get_build_webhook(fortesting.ProjectID)
parameter_group_id = ""
if webhook.WHParameters and "=" in webhook.WHParameters:
parameter_group_id = webhook.WHParameters.split('=')[1]
taskid = webhook.WHURL.strip('/').split('/')[-1:][0]
CITaskService.start_ci_task(request, taskid, parameter_group_id, fortesting.VersionID)
ForTestingService.log_build_activity(request.user, fortesting)
def build_with_parameter_page(request,task_id,task_property):
''' index page'''
try:
page_worker=CIDeployPageWorker(request)
if CITaskParameterService.has_parameters(task_id):
return page_worker.build_with_parameter_fullpage(request,task_id,task_property)
else:
CITaskService.start_ci_task(request,task_id,0,0)
except Exception as ex:
SimpleLogger.exception(ex)
return redirect('/ci/dashboard',request)
def tq_done(request):
try:
tq_id = request.GET.get("tq_id", "")
task_history = CITaskHistory.objects.get_by_tqid(int(tq_id))
CITaskHistoryService.save_build_log(tq_id)
CITaskHistoryService.clean_build_history(task_history.id)
CITQService.update_task_queue_status(request)
CITaskService.send_task_enqueue_message()
result = SuccessResponse("success", dict())
except Exception as ex:
SimpleLogger.exception(ex)
result = ErrorResponse(str(ex), dict())
return HttpResponse(result.get_json())
def update(self, request, *args, **kwargs):
partial = kwargs.pop('partial', False)
instance = self.get_object()
serializer = self.get_serializer(instance, data=request.data, partial=partial)
serializer.is_valid(raise_exception=True)
self.perform_update(serializer)
CITaskService.save_task_config(request.data,instance)
if getattr(instance, '_prefetched_objects_cache', None):
# If 'prefetch_related' has been applied to a queryset, we need to
# forcibly invalidate the prefetch cache on the instance.
instance._prefetched_objects_cache = {}
return Response(serializer.data)
def get(self, request, *args, **kwargs):
message = "success"
try:
print(self.request.GET)
status = self.request.GET.get('status', 5)
build_message = self.request.GET.get('error_msg', '')
task_queue = self.get_object()
CITaskHistoryService.save_build_log(str(task_queue.id), True)
CITQService.update_task_queue_status(task_queue.id, status,
build_message)
CITaskService.send_task_enqueue_message()
except Exception as ex:
print(ex)
message = str(ex)
return response.Response({"message": message})
def get_task_history_fullpage(self, request,task_id,task_property):
dm_products = CITaskService.get_products_include_me(request)
left_nav_bar = self.get_task_left_bar(request)
sub_nav_bar = self.get_task_sub_navbar(request,dm_products,0,task_id,task_property)
ci_task_history_webpart = self.ci_testing_history_webpart(request,task_id)
page_fileds = {"left_nav_bar":left_nav_bar, "sub_nav_bar":sub_nav_bar, "ci_task_history":ci_task_history_webpart}
return self.get_page(page_fileds,CITaskPath.task_index_path,request)
def filter_tasks(self, request):
filters = request.POST.get('filters')
if filters:
dm_ci_tasks = CITaskService.filter_tasks(request)[0:9]
else:
dm_ci_tasks = list()
return self.get_ci_task_list_controll(request, dm_ci_tasks, True)
def search_tasks(self, request):
keyword = request.POST.get('keyword')
if keyword:
dm_ci_tasks = CITaskService.search_tasks(request)[0:9]
else:
dm_ci_tasks = list()
return self.get_ci_task_list_controll(request, dm_ci_tasks, True)
def get_agent_filter_dropdown_list(self, condations_list):
vm_agent_filter_tags = list()
for dm_tag in CITaskService.get_agent_filter__tags():
tem_tag = VM_Tag(dm_tag, condations_list)
vm_agent_filter_tags.append(tem_tag)
pagefileds = {"filter_condations":vm_agent_filter_tags}
return self.get_webpart(pagefileds, CICommonControllPath.agent_condations_controll)
def get_ci_task_tag_menu(self):
ci_tags = list()
for dm_tag in CITaskService.get_avalible_menu_tags(1):
tem_tag = VM_Tag(dm_tag,'0,0')
ci_tags.append(tem_tag)
pagefileds = {"ci_tags":ci_tags}
return self.get_webpart(pagefileds, CICommonControllPath.task_tag_filter_menu)
def stop_task(request,task_id):
result="Flase"
try:
result=CITaskService.stop_ci_task(request,task_id)
except Exception as ex:
SimpleLogger.exception(ex)
return HttpResponse(result)
def start_task(request,task_id):
result="Flase"
try:
parameter_group_id=request.POST.get('parameter_group_id')
result=CITaskService.start_ci_task(request,task_id,parameter_group_id,0)
except Exception as ex:
SimpleLogger.exception(ex)
return HttpResponse(result)
def get_ci_tag_list(self, request):
all_tags = CITaskService.get_avalible_menu_tags(4)
vm_tags = list()
for dm_tag in all_tags:
tmp_tag = VM_Tag(dm_tag, 0)
vm_tags.append(tmp_tag)
page_fileds = {"ci_tags": vm_tags}
return self.get_webpart(page_fileds, CISettingsPath.settings_tag_list)
def dashboard_more_task_list(self, request):
# page_size=int(request.POST.get("page_size",0))
# start_index=int((page_size/9)*9)
# end_index=int(((page_size/9)+1)*9)
dm_ci_tasks = CITaskService.filter_tasks(request)
task_list_controll = self.get_ci_task_list_controll(
request, dm_ci_tasks, False)
return task_list_controll
def create(request):
taskid=0
try:
ci_task=CITaskService.create_ci_task(request)
taskid=ci_task.id
except Exception as ex:
SimpleLogger.exception(ex)
return HttpResponse(taskid)
def get(self,request, *args, **kwargs):
task_id =int(self.kwargs['id'])
operation = self.kwargs['operation'].strip(' ')
build_parameter = self.request.GET.get('BuildParameter',None)
task_uuid = self.request.GET.get('TaskUUID',None)
task_queueid = self.request.GET.get('TQID',None)
result = [0,'任务'+ str(task_id) +'指令下发失败，请联系管理员或者重试！']
try:
if operation == 'start':
result = CITaskService.start_ci_task(request,task_id,build_parameter,0)
if operation == 'stop' and task_uuid:
result = CITaskService.stop_ci_task(request,task_id)
if operation == 'prelog' and task_queueid:
result = RedisService.get_value("ci_build_log"+str(task_queueid))
except Exception as ex:
SimpleLogger.exception(ex)
return Response({'tqid': result[0], 'message': result[1],'TaskUUID': result[2]})
def get_task_tag_menu(self, task, taskrole, tag_type):
tags = list()
for tag in CITaskService.get_avalible_menu_tags(tag_type):
tmp_tag = VM_Tag(tag, task.Tags)
tags.append(tmp_tag)
context_fileds = {'tags': tags, 'tagrole': taskrole}
return self.get_webpart(context_fileds,
ProjectTaskPath.tag_menu_template_path)
def create(self, request, *args, **kwargs):
ci_task = CITaskService.create_ci_task(request.data, request.user)
serializer = ci_serializer.CITaskSerializer(instance=ci_task,
data=request.data)
serializer.is_valid(raise_exception=True)
headers = self.get_success_headers(serializer.data)
return Response(serializer.data,
status=status.HTTP_201_CREATED,
headers=headers)
def create_start_trigger(request, trigger_data, user):
trigger = CITaskApiTrigger()
trigger = CITaskTriggerService.init_trigger(trigger_data, trigger)
trigger.IsActive = 1
trigger.ActionType = 1
start_result = CITaskService.start_ci_task(request, trigger.TaskID,
trigger.BuildParameter, 0)
trigger.TaskQueueUUID = start_result[2]
trigger.save()
CITaskTriggerService.log_create_activity(user, trigger)
return trigger
def upload_package(request):
message = dict()
message['msg'] = "success"
try:
message['result'] = CITaskService.upload_package(request)
if message['result'] == "":
message['msg'] = ResCIService.ci_package_upload_package_fail
except Exception as ex:
message['msg'] = str(ex)
SimpleLogger.exception(ex)
return HttpResponse(str(message))
def get_ci_task_fullpage(self, request, task_type, sub_nav_action):
dm_products = CITaskService.get_products_include_me(request)
left_nav_bar = self.get_task_left_bar(request)
sub_nav_bar = self.get_task_sub_navbar(request, dm_products,
sub_nav_action)
ci_task_webpart = self.get_ci_task_list_webpart(
request, task_type, sub_nav_action, "所有任务")
page_fileds = {
"left_nav_bar": left_nav_bar,
"sub_nav_bar": sub_nav_bar,
"ci_task_list": ci_task_webpart
}
return self.get_page(page_fileds, CITaskPath.task_index_path, request)
def get_ci_task_list_webpart(self, request, task_type, sub_nav_action,
page_title):
dm_ci_tasks = CITaskService.get_product_ci_tasks(
request, task_type, sub_nav_action)
task_list_controll = self.get_ci_task_list_controll(
request, dm_ci_tasks)
pagefileds = {
"ci_task_listcontroll": task_list_controll,
"task_type": task_type,
"product_id": sub_nav_action,
"ci_task_page_title": page_title
}
return self.get_webpart(pagefileds, CITaskPath.task_list_webpart)
def get_task_list(request):
''' index page'''
result=""
try:
page_worker=CITaskPageWorker(request)
task_id=request.POST.get("task_id")
ci_task=CITask.objects.get(int(task_id))
sub_nav_action=request.POST.get("sub_nav_action")
dm_ci_tasks=CITaskService.get_product_ci_tasks(request, ci_task.TaskType, sub_nav_action)
result=page_worker.get_ci_task_list_controll(request,dm_ci_tasks,True)
except Exception as ex:
SimpleLogger.exception(ex)
return HttpResponse(result)
def get_dashboard_task_list_webpart(self, request):
dm_ci_tasks = CITaskService.get_my_ci_tasks(request, 0, "all")
task_list_controll = self.get_ci_task_list_controll(
request, dm_ci_tasks, False)
project_pageworker = ProjectPageWorker(request)
project_filter = project_pageworker.get_project_menu(
request, CICommonControllPath.project_filter_menu)
ci_common_pageworker = CICommonControllPageWorker(request)
task_tag_filter = ci_common_pageworker.get_ci_task_tag_menu()
pagefileds = {
"ci_task_listcontroll": task_list_controll,
"project_filter": project_filter,
"ci_task_page_title": "dashboard"
}
pagefileds['task_tag_filter'] = task_tag_filter
return self.get_webpart(pagefileds, CITaskPath.task_list_webpart)
def create_stop_trigger(request, trigger_data, user):
tr_uuid = trigger_data.get('TriggerUUID', None)
trigger = None
if tr_uuid:
trigger = CITaskApiTrigger.objects.get_by_truuid(tr_uuid)
if trigger:
trigger = CITaskTriggerService.init_trigger(
trigger_data, trigger)
trigger.IsActive = 1
trigger.ActionType = 2
stop_result = CITaskService.stop_ci_task(
request, trigger.TaskID, trigger.TaskQueueUUID)
trigger.TaskQueueUUID = stop_result[2]
trigger.save()
CITaskTriggerService.log_create_activity(user, trigger)
return trigger