def simpleService(request, service_id):
"""
간략한 서비스 정보
:param request:
:param service_id:
:return:
"""
if request.is_ajax() and request.method == 'POST':
logger.info("simpleServicePOST")
control = ControlEngine(request.session.get("ctrl_header"))
service_map = control.get_map(service_id)
# logger.info(service_map)
logger.info("simpleServicePOST_end")
if service_map.get("success"):
try:
if service_map["success"].get("map_link_list"):
map_data = service_map["success"]["map_link_list"]
if type(map_data) == str or type(map_data) == unicode:
map_data = json.loads(map_data.replace('\\"', '"'))
resource_list = map_data.get("resources")
links = map_data.get("links")
as_links = map_data.get("asLinks")
used_security_group_list = map_data.get(
"used_security_group_list")
security_types = map_data.get("security_types")
response = {
"success": {
"resources": resource_list,
"links": links,
"as_links": as_links
}
}
if used_security_group_list:
response[
"used_security_group_list"] = used_security_group_list
if security_types:
response["security_types"] = security_types
return JsonResponse(response)
else:
return JsonResponse({
"error": {
"message": service_id + u" 연결정보가 없습니다.",
"response": service_map
}
})
except Exception as e:
return JsonResponse({
"error": {
"message": service_id + u" 연결정보가 올바르지 않습니다.",
"response": service_map,
"exception": e.message
}
})
else:
return JsonResponse(service_map)
def createChaining(request, service_id):
if request.is_ajax() and request.method == 'POST':
token = request.session.get('passToken')
auth_url = request.session.get("auth_url")
ctrl_header = request.session.get('ctrl_header')
control = ControlEngine(ctrl_header)
service_detail = control.get_service(service_id)
response = {"success": {}, "error_msg_list": []}
if service_detail.get("success"):
response["success"]["service"] = service_detail["success"]
else:
response["error_msg_list"].append(service_detail.get("error"))
map_data = control.get_map(service_id)
if map_data.get("success"):
response["success"]["links"] = map_data["success"][
"map_link_list"].get("links")
response["success"]["asLinks"] = map_data["success"][
"map_link_list"].get("asLinks")
response["success"]["resources"] = map_data["success"][
"map_link_list"].get("resources")
else:
response["error_msg_list"].append(map_data.get("error"))
neutron = NeutronRestAPI(auth_url, token)
public_network = neutron.get_external_network(
{"router:external": True})
if public_network.get("success"):
response["success"]["public_network"] = public_network[
"success"].get("networks")
else:
response["error_msg_list"].append(public_network.get("error"))
return JsonResponse(response)
elif request.method == 'POST':
jsonData = request.POST.get("jsonData")
return render(request, 'service/create_chaining.html',
{'service_detail': jsonData})
else:
token = request.session.get('passToken')
if not token:
return redirect("/dashboard/domains/?next=/dashboard/service/" +
service_id + "/chaining/create")
return render(request, 'service/create_chaining.html', {})
def createChainingDev(request, service_id):
if request.is_ajax() and request.method == 'POST':
token = request.session.get('passToken')
auth_url = request.session.get("auth_url")
ctrl_header = request.session.get("ctrl_header")
control = ControlEngine(ctrl_header)
neutron = NeutronRestAPI(auth_url, token)
service_detail, map_data = control.get_service_detail_and_link_list(
service_id)
# rel
map_data = control.get_map(service_id)
public_network = neutron.get_external_network(
{"router:external": True})
#dev # {'success':{'id':"",'chain_id':""}}
return JsonResponse({
'success': {
'service': {
"service_detail":
service_detail["success"]["service_detail"]
},
"links": map_data["success"]["map_link_list"],
"public_network": public_network
}
})
#rel
# return JsonResponse({'service': service_detail["success"], 'instance_list':instanceList, "links": map_data["success"]["map_link_list"], "public_network": public_network})
else:
sfc_name = request.POST.get("sfc_name")
sfc_desc = request.POST.get("sfc_desc")
# print "~~~~~~~~~~~~~~~"
# print sfc_name
# print sfc_desc
return render(request, 'service/create_chaining.html', {
'sfc_name': sfc_name,
'sfc_desc': sfc_desc
})
def modifyService(request, service_id):
"""
서비스 수정 페이지
:param request:
:param service_id:
:return:
"""
if request.method == 'POST':
logger.info("detailServicePOST")
control = ControlEngine(request.session.get("ctrl_header"))
token = request.session.get("passToken")
auth_url = request.session.get("auth_url")
template = control.get_template(service_id)
if template.get("success"):
user_template = template["success"].get("user_template")
user_template["service_id"] = service_id
service_detail = {"success": {"service_detail": user_template}}
else:
service_detail = template
map_data = control.get_map(service_id)
public_network = []
logger.info("detailServicePOST_end_public_network")
try:
neutron = NeutronRestAPI(auth_url, token)
result = neutron.get_network_list()
except:
logger.warning("get public_network fail")
return JsonResponse(service_detail)
else:
if result.get("success"):
public_network = filter(
lambda network: network["router:external"],
result["success"]["networks"])
if service_detail.get("success"):
json_dic = {
"success": service_detail["success"],
"public_network": public_network
}
if map_data["success"].get("map_link_list"):
links = map_data["success"]["map_link_list"].get("links")
as_links = map_data["success"]["map_link_list"].get("asLinks")
resources = map_data["success"]["map_link_list"].get(
"resources")
security_types = map_data["success"]["map_link_list"].get(
"security_types")
json_dic.update({
"links": links,
"asLinks": as_links,
"resources": resources,
"security_types": security_types
})
return JsonResponse(json_dic)
else:
return JsonResponse(service_detail)
else:
token = request.session.get('passToken')
if not token:
return redirect("/dashboard/domains/?next=/dashboard/service/" +
service_id + "/detail")
logger.info("detailService_end")
response = render(request, 'service/info.html', {})
return response
def get_security_group_info(request):
token = request.session.get("passToken")
domain_name = request.session.get("domain_name")
project_name = request.session.get("project_name")
user_name = request.session.get("user_name")
if request.method == "POST":
data = request.POST.get("data")
control = ControlEngine(request.session.get("ctrl_header"))
data = json.loads(data)
service_id = data.get("service_id")
server_id = data.get("server_id")
service_info = control.get_service_vm(
service_id) # service_id 에 해당하는 서비스에 속한 서버 리스트 반환
if service_info.get("success"):
# print "=============success보안장비정보=================="
# print "service_id: ", service_id, "server_id: ", server_id
# print "data", data
vmList = service_info["success"].get("vm_list")
vm_name_list = [
vm.get("vm_name") for vm in vmList
if vm.get("vm_id") == server_id
]
if len(vm_name_list) != 0:
searchVmName = vm_name_list[0]
smap_data = control.get_map(service_id)
if smap_data.get("success"):
map_data = smap_data.get("success").get("map_data")
used_security_group_list = map_data.get(
"used_security_group_list"
) # service_id에 해당하는 맵데이터에서 사용한 보안장비찾기
if used_security_group_list:
print "used_security_group_list: ", used_security_group_list
used_security_group_id_list = []
for used_security_group in used_security_group_list:
if used_security_group.get(
"vm_name"
) == searchVmName: # 사용된 보안장비의 가상서버 목록중 같은 이름이 있는지 확인
used_security_group_id_list.append(
used_security_group["security_id"]
) # 위조건에 만족한 보안장비 id저장
# print "used_security_group_id_list: ", used_security_group_id_list
if len(used_security_group_id_list) > 0:
used_security_group_id = used_security_group_id_list[
0] # 저장된 보안장비 ID로 db에서 정보찾기
db_nm = request.session.get("domain_db_nm")
db_user = request.session.get("domain_db_user")
db_pass = request.session.get("domain_db_pass")
db_ip = request.session.get("domain_db_ip")
db_port = request.session.get("domain_db_port")
conn = SOAControlDomainDBConnector(db_nm=db_nm,
db_user=db_user,
db_pass=db_pass,
db_ip=db_ip,
db_port=db_port)
params = (used_security_group_id)
try:
select_security_resource = conn.select(
SELECT_SECURITY_RESOURCE_GROUP, params)
if len(select_security_resource) > 0:
security_resource = select_security_resource[
0]
security_resource["data"] = {
"nodes":
security_resource.get("topology_json"),
"links":
security_resource.get("link_json"),
"security_types":
security_resource.get("security_json")
}
result = {
"success": {
"security_resource":
security_resource
}
}
else:
raise Exception(used_security_group_id +
_(u"은 존재하지 않습니다."))
except Exception as e:
result = {
"error": {
"message": str(e),
"title": "error"
}
}
else:
result = {
"error": {
"message": _("해당 서버에는 보안정보가 없습니다."),
"title": "error"
}
}
else:
result = {
"error": {
"message": _("해당 서비스에는 보안정보가 없습니다."),
"title": "error"
}
}
else:
result = {
"error": {
"message": _("해당 서버가 없습니다."),
"title": "error"
}
}
elif service_info.get("error"):
result = service_info.get("error")
else:
# print "=============error보안장비정보=================="
result = {"error": {"message": _(u"잘못된 아이디"), "title": "error"}}
return JsonResponse(result)
else:
response = render('404.html', {})
response.status_code = 404
return response
def recover_vm(recovery_server_info, ctrl_header, domain):
"""
가상머신 장애 복구 process
:param recovery_server_info:
:param ctrl_header:
:param domain:
:return:
"""
floating_ip_id = recovery_server_info.get("floating_ip_id")
vm_id = recovery_server_info.get("vm_id")
vm_name = recovery_server_info.get("vm_name")
service_id = recovery_server_info.get("service_id")
token = ctrl_header.get("X-Auth-Token")
auth_url = ctrl_header.get("X-Host-Uri")
project_name = ctrl_header.get("X-Tenant-Name")
result = {}
err_msg_list = []
neutron = NeutronRestAPI(auth_url, token)
nova = NovaRestAPI(auth_url, token)
# floatingip 필요한 정보 추출, 삭제
result_info_or_delete_floating_ip, floating_ip = get_floating_info_and_delete(neutron, floating_ip_id)
# port 필요한 정보 추출, 삭제
result_info_or_delete_port_list, port_list = get_port_list_and_delete(neutron, vm_id)
# vm 삭제
result_delete_server = nova.delete_server(vm_id)
if result_info_or_delete_floating_ip:
err_msg_list.append(result_info_or_delete_floating_ip)
err_msg_list.extend(result_info_or_delete_port_list)
if result_delete_server.get("error"):
err_msg_list.append(result_delete_server["error"])
# error 가 없으면
if len(err_msg_list) < 1:
control = ControlEngine(ctrl_header)
result_template = control.get_template(service_id)
result_map = control.get_map(service_id)
if result_template.get("success") and result_map.get("success"):
template = get_recovery_template(result_template["success"].get("user_template"), vm_name, port_list)
map_data = get_recovery_map(result_map["success"], vm_name)
result_update_map = control.update_map(service_id, map_data.replace('\\', ''))
result_update_service = control.update_service(template, service_id)
if result_update_service.get("success"):
result_check = check_update_status(control, auth_url, domain, project_name, service_id)
if result_check.get("success"):
vm_list = result_check["success"]["service_detail"]["vm_list"]
recovery_vm_name = vm_name
if "_recovery" in vm_name:
p = re.compile("_recovery\[(\d)\]")
m = p.search(vm_name)
if m:
recovery_cnt = m.group(1)
recovery_cnt = str(int(recovery_cnt) + 1)
recovery_vm_name = vm_name.replace("_recovery[" + m.group(1) + "]",
"_recovery[" + recovery_cnt + "]")
else:
recovery_vm_name = vm_name + "_recovery[1]"
vm_id = [vm.get("vm_id") for vm in vm_list if vm.get("vm_name") == recovery_vm_name][0]
neutron.update_token(result_check["success"]["ctrl_header"].get("X-Auth-Token"))
result_create_floting_ip = create_floating_ip_for_recovery(neutron, recovery_server_info, vm_id)
if result_create_floting_ip.get("error"):
err_msg_list.extend(result_create_floting_ip["error"].get("err_msg_list"))
else:
result["success"] = True
else:
err_msg_list.append(result_check.get("error"))
if result_update_service.get("error"):
err_msg_list.append(result_update_service["error"])
if result_update_map.get("error"):
err_msg_list.append(result_update_map["error"])
if result_template.get("error"):
err_msg_list.append(result_template["error"])
if result_map.get("error"):
err_msg_list.append(result_map["error"])
if len(err_msg_list) > 0:
result["error"] = {"err_msg_list": err_msg_list}
return result
