def search_issue(all_issue, user_id):
key = str(user_id) + "_issue_searchkeyword"
result = all_issue
if RedisService.has_key(key):
search_word = RedisService.get_value(key)
result = result.filter(Title__icontains=search_word)
return result
def update_issue_filter_cache(key, filter_id):
RedisService.delete_value(key)
if str(filter_id) != "0":
filter = IssueFilter.objects.get(int(filter_id))
if filter.FilterCacheString:
for filter_item in eval(filter.FilterCacheString):
RedisService.set_svalue(key, filter_item, 7 * 24 * 3600)
def cache_issue_filter(key, values):
field_name = values.split(":")[0]
old_filter = RedisService.get_svalue(key)
for item in old_filter:
filter_member = item
if filter_member.startswith(field_name):
RedisService.delete_smember(key, filter_member)
RedisService.set_svalue(key, values, 7 * 24 * 3600)
def all_issues(project_id, user_id):
result = IssueService.project_all_issues(project_id)
filter_key = str(user_id) + "_issue_filter"
if RedisService.has_key(filter_key):
filter_values = RedisService.get_svalue(filter_key)
result = IssueService.filter_all_issues(result, filter_values)
result = IssueService.search_issue(result, user_id)
return result
def save(self):
channel = self.validated_data['channel']
message = self.validated_data['message']
delivered_count=RedisService.publish_message(channel, message)
RedisService.websocket_publish_message(channel,message)
self.validated_data['delivered_count']=delivered_count
def remove_cache(request):
message = "True"
try:
cache_key = request.POST.get("cache_key")
RedisService.delete_value(cache_key)
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def clean_issue_filter(request):
message = True
try:
word_key = str(request.user.id) + "_issue_searchkeyword"
filter_key = str(request.user.id) + "_issue_filter"
RedisService.delete_value(word_key)
RedisService.delete_value(filter_key)
except Exception as ex:
SimpleLogger.exception(ex)
message = str(ex)
return HttpResponse(message)
def cache_issue_attachments(upload_file, user):
message = {"cache_key": "", "message": "上传文件超过10M"}
try:
if RedisService.validate_upload_file(upload_file, 10 * 1024 * 1024,
None):
cached_key = str(user.id) + "_" + str(time.time())
RedisService.set_object(cached_key, upload_file, 1800)
message["cache_key"] = cached_key
except Exception as ex:
SimpleLogger.exception(ex)
message["message"] = str(ex)
return message
def add_message(request):
result="OK"
try:
message=request.POST.get("msg",'')
tq_id=request.POST.get("tq_id")
message_intime=message
RedisService.append_value("ci_build_log"+tq_id,message_intime,7200)
welcome = RedisMessage(message_intime) # create a welcome message to be sent to everybody
RedisPublisher(facility=tq_id, broadcast=True).publish_message(welcome)
except Exception as ex:
SimpleLogger.exception(ex)
result=str(ex)
return HttpResponse(result)
def cached_file(request):
message = "0,上传失败"
try:
upload_file = request.FILES['attachment[0]']
if RedisService.validate_upload_file(upload_file, 10 * 1024 * 1024,
None):
cached_key = str(request.user.id) + "_" + str(time.time())
RedisService.set_object(cached_key, upload_file, 1800)
message = cached_key + ",null"
except Exception as ex:
SimpleLogger.exception(ex)
message = "0," + str(ex)
return HttpResponse(message)
def get_my_issue_item(self,user_id,user_role):
issue_list_controll=self.get_my_issue_more(user_id,0,user_role)
issue_count=len(IssueService.my_issue(user_id,user_role))
key=str(user_id)+"_issue_searchkeyword"
search_word=RedisService.get_value(key)
pagefileds={"issue_list_controll":issue_list_controll,"issue_count":issue_count,"search_word":search_word}
return self.get_webpart(pagefileds,ProjectIssuePath.issue_item_list)
def store_cached_file(cached_file_keys):
result = ""
keys = cached_file_keys.split(',')
for key in keys:
if key != "":
temp_file = RedisService.get_object(key)
if temp_file != None:
RedisService.delete_value(key)
mongo_id = MongoDBService.save_file(
temp_file, IssueMongoFile)
file_id = FileInfoService.add_file(0, mongo_id,
temp_file.name, 1, 0,
temp_file.size)
if file_id != 0:
result = result + str(file_id) + ","
return result
def post(self, request, *args, **kwargs):
result = "OK"
try:
message = request.data.get("msg", '')
tq_id = request.data.get("tq_id")
message_intime = message
RedisService.append_value("ci_build_log" + str(tq_id),
message_intime, 7200)
welcome = RedisMessage(
message_intime
) # create a welcome message to be sent to everybody
RedisPublisher(facility=str(tq_id),
broadcast=True).publish_message(welcome)
except Exception as ex:
SimpleLogger.exception(ex)
result = str(ex)
return Response(result)
def create_issue_filter(project_id, filter_id, filter_name, user_id):
if str(filter_id) == "0":
temp_filter = IssueFilter()
else:
temp_filter = IssueFilter.objects.get(int(filter_id))
temp_filter.Project = int(project_id)
temp_filter.FilterName = filter_name
temp_filter.Creator = int(user_id)
filter_key = str(user_id) + "_issue_filter"
if RedisService.has_key(filter_key):
filter_values = RedisService.get_svalue(filter_key)
temp_filter.FilterString = IssueService.get_filter_string(filter_values)
temp_filter.FilterUIConfig = IssueService.filter_value_dict(filter_key)
temp_filter.FilterCacheString = filter_values
temp_filter.Scope = 1
temp_filter.save()
return temp_filter.id
def get(self,request, *args, **kwargs):
result = ''
task_queueid = self.kwargs.get('tq_id',None)
try:
if task_queueid:
result = RedisService.get_value("ci_build_log"+str(task_queueid))
except Exception as ex:
SimpleLogger.exception(ex)
return Response({'PreLog':result})
def save_build_log(tq_id,tq_done=False):
file_name="ci_build_log"+tq_id+".log"
build_log=RedisService.get_value("ci_build_log"+tq_id)
result=MongoDBService.save_content_asfile(file_name, build_log,BuildLogMongoFile)
file_id=FileInfoService.add_file(0,result,file_name,1,0,len(build_log))
RedisService.delete_value("ci_build_log" + tq_id)
if tq_done:
temp_output = CITaskStepOutput()
temp_output.ProductType = 1
temp_output.ProductID = file_id
task_queue = TaskQueue.objects.get(int(tq_id))
task_history = CITaskHistory.objects.get_history_by_uuid(task_queue.TaskUUID)
temp_output.TaskHistoryID = task_history.id
temp_output.TaskID = task_history.CITaskID
temp_output.StepID = ""
temp_output.StageHistoryID = 0
temp_output.save()
else:
RedisService.set_value("ci_build_log"+tq_id,"")
return file_id
def save_build_log(tq_id):
file_name = "ci_build_log" + tq_id + ".log"
build_log = RedisService.get_value("ci_build_log" + tq_id)
result = MongoDBService.save_content_asfile(file_name, build_log,
BuildLogMongoFile)
file_id = FileInfoService.add_file(0, result, file_name, 1, 0,
len(build_log))
task_history = CITaskHistory.objects.get_by_tqid(int(tq_id))
if file_id:
task_history.BuildLogID = file_id
else:
task_history.BuildLogID = 0
task_history.save()
def get(self, request, *args, **kwargs):
result = True
try:
file_id = kwargs.get('file_id')
temp_file = RedisService.get_object(file_id)
if temp_file:
result = temp_file
else:
result = FileInfoService.get_file(int(file_id), IssueMongoFile)
except Exception as ex:
result = str(ex)
SimpleLogger.exception(ex)
return HttpResponse(result, content_type="application/octet-stream")
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 filter_value_dict(filter_key):
result = dict()
filter_values = RedisService.get_svalue(filter_key)
for filter_item in filter_values:
filter_item_value = filter_item
print(filter_item_value)
filter_field = filter_item_value.split(":")[0]
filter_value = filter_item_value.split(":")[1]
if filter_value == "":
filter_value = "0,0"
if filter_field.endswith("_s"):
dict_key = filter_field.replace("_s", "")
result[dict_key] = eval("[" + filter_value + "]")
else:
if filter_field == "CreationTime":
start_date = filter_value[:11].strip()
end_date = filter_value[12:].strip()
result[filter_field] = eval("['" + start_date + "','" + end_date + "']")
else:
result[filter_field] = filter_value
return result
def get_build_log_content(self, tq_id):
result = ""
ci_build_logs = RedisService.get_value("ci_build_log" + tq_id)
return ci_build_logs
def send_task_enqueue_message():
RedisService.websocket_publish_message("TASKSTATUSCHANGE",
'Task enqueue now!')
def cache_issue_search_word(key, value):
if RedisService.has_key(key):
RedisService.delete_value(key)
RedisService.set_value(key, value, 1800)
else:
RedisService.set_value(key, value, 1800)
