def delete_service(request, service_id):
"""
서비스 삭제
:param request:
:param service_id:
:return:
"""
logger.info("delete_service")
ctrl_header = request.session.get("ctrl_header")
control = ControlEngine(ctrl_header)
result = control.delete_service(service_id)
# result = {"success":{"error_msg_list":{"a":"A", "b":"B", "c":"C"}}}
# if result.get("success"):
# 관리포탈 동기화용
# conn = SOAControlDBConnector.getInstance()
#
# params = (request.session.get("domain_name"), request.session.get("project_name"))
# if len(conn.select(SELECT_SOAC_PROJECT, params)) >= 1:
# params = (
# request.session.get("domain_name"),
# request.session.get("project_name"),
# service_id,
# )
# try:
# from pprint import pprint
# print "=============params============="
# pprint(params)
# delete_service = conn.delete(DELETE_SOAC_SERVICE, params)
# print "================result================ ", delete_service
# temp = {"success": {"message": "서비스삭제", "title": "성공"}}
# except Exception as e:
# temp = {"error": {"message": str(e), "title": "error"}}
# 동기화용 끝
return JsonResponse(result)
def create_dst_routing(request, router_id):
control = ControlEngine(request.session.get("ctrl_header"))
data = json.loads(request.POST.get("data"))
netnodeip = request.POST.get("netnodeip")
result = control.create_route_dst_rule_path("qrouter-" + router_id,
netnodeip, data)
return JsonResponse(result)
def getChainingList(request, service_id):
if request.is_ajax() and request.method == 'POST':
ctrl_header = request.session.get('ctrl_header')
control = ControlEngine(ctrl_header)
result = control.get_sfc_list(service_id)
return JsonResponse(result)
def create_service(request):
"""
서비스 생성
:param request:
:return:
"""
if request.is_ajax() and request.method == 'POST':
logger.info("create_service")
service_template = json.loads(request.POST.get("service_templates"))
service_template["description"] = unicode(
service_template.get("description"))
data_dic = json.loads(request.POST.get("mapData"))
control = ControlEngine(request.session.get("ctrl_header"))
result = control.create_service(service_template)
if result.get("success"):
logger.info("create_map")
result["success"]["createMap"] = control.create_map(
result["success"]["service_id"], json.dumps(data_dic))
service_info = result["success"]
# 관리포탈 동기화용
if request.POST.get("soam_synchronize") == "true":
try:
logger.debug("[synchronize ...]")
synchronize_soam(request, service_info, data_dic)
except Exception as e:
error_str = """
Title: {}
Traceback: {}
""".format(e.message,
traceback.format_exc().strip())
logger.debug("[synchronize fail]\n{}".format(error_str))
temp = {"error": {"message": str(e), "title": "error"}}
return JsonResponse(result)
def get_all_service_list(request):
"""
서비스 전체 조회 페이지
:param request:
:return:
"""
user_name = request.session.get("user_name")
token = request.session.get('passToken')
ctrl_header = request.session.get('ctrl_header')
control = ControlEngine(ctrl_header)
logger.debug("user_name: {}\nctrl_header: {}".format(
user_name, ctrl_header))
if user_name == 'admin':
logger.debug("true")
result = control.get_all_service_list()
logger.debug(result)
if result.get("success"):
result = result.get("success")
if not token:
return redirect(
"/dashboard/domains/?next=/dashboard/service/all_service")
return render(request, 'service/all_index.html', result)
else:
return redirect("/dashboard/service")
def getPortList(request, service_id):
if request.is_ajax() and request.method == 'POST':
resource_type = request.POST.get("resource_type")
resource_id = request.POST.get("resource_id")
ctrl_header = request.session.get("ctrl_header")
control = ControlEngine(ctrl_header)
result = control.get_port_list(resource_type, resource_id)
return JsonResponse(result)
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 resume_service(request, service_id):
"""
서비스 재시작
:param request:
:param service_id:
:return:
"""
logger.info("resume_service")
ctrl_header = request.session.get("ctrl_header")
control = ControlEngine(ctrl_header)
result = control.resume_service(service_id)
return redirect("/dashboard/service")
def switch_project_with_token(request):
token = request.session.get("passToken")
if request.method == 'POST':
data = json.loads(request.POST.get("data"))
project_name = data.get("project_name")
domain_name = request.session.get("domain_name")
auth_url = request.session.get("auth_url")
try:
keystone = KeystoneRestAPI(auth_url, token)
except Unauthorized as e:
request.session["error"] = {
"title": e.message,
"message": e.details
}
return JsonResponse({
"error": {
"title": e.message,
"message": e.details,
"code": 401
}
})
# result = keystone.get_token_with_scoped_by_token(project_id=project_id)
result = keystone.get_token_with_scoped_by_token(
domain_name=domain_name, project_name=project_name)
if result.get("success"):
# request.session.set_expiry(SESSION_COOKIE_AGE)
token = result['success']['token']
request.session["passToken"] = token
request.session["project_name"] = project_name
roles = result["success"].get("roles")
if roles:
roles_str = ','.join(role.get("name") for role in roles)
else:
roles_str = ""
user = result["success"].get("user")
project = result["success"].get("project")
request.session["user_id"] = user.get("id")
request.session["user_name"] = user.get("name")
request.session["project_id"] = project.get("id")
request.session["roles"] = roles_str
ctrl_engine = ControlEngine(token=token,
project_id=project.get("id"),
project_name=project_name,
user_id=user.get("id"),
user_name=user.get("name"),
roles=roles_str,
auth_url=auth_url)
request.session["ctrl_header"] = ctrl_engine.get_header()
return JsonResponse(result)
def get_console_url(request):
"""
가상머신 vnc console 주소 얻기
:param request:
:return:
"""
if request.is_ajax() and request.method == 'POST':
ctrl_header = request.session.get("ctrl_header")
control = ControlEngine(ctrl_header)
vm_id = request.POST.get("vm_id")
result = control.get_vnc_console(vm_id)
return JsonResponse(result)
def get_resource_data(request):
"""
각 자원 조회
:param request:
:return:
"""
# if request.is_ajax() and request.method == 'POST':
ctrl_header = request.session.get("ctrl_header")
auth_url = request.session.get("auth_url")
token = request.session.get("passToken")
control = ControlEngine(ctrl_header)
resource_type = request.GET.get("resource_type")
resource_id = request.GET.get("resource_id")
if resource_type == "AUTOSCALING" or resource_type == "LB" or resource_type == "AS_SERVER":
data = json.loads(request.GET.get("data"))
return render(
request, 'service/include/right_pop_' + resource_type.lower() +
'_info.html', {"data": data})
else:
result = control.get_resource(resource_type, resource_id)
if result.get("success"):
if resource_type == "SERVER":
if result["success"]["server"].get("flavor"):
nova = NovaRestAPI(auth_url, token)
result_flavor = nova.get_flavor(
result["success"]["server"]["flavor"]["id"])
if result_flavor.get("success"):
result["success"]["server"]["flavor"][
"added_data"] = result_flavor["success"]["flavor"]
else:
logger.error(result_flavor)
if result["success"]["server"].get("image"):
glance = GlanceRestAPI(auth_url, token)
result_image = glance.get_image(
result["success"]["server"]["image"]["id"])
if result_image.get("success"):
result["success"]["server"]["image"][
"added_data"] = result_image["success"]
else:
logger.error(result_image)
else:
logger.info("showResource(" + resource_type + ")")
# logger.info(result)
return render(
request, 'service/include/right_pop_' + resource_type.lower() +
'_info.html', result.get("success"))
else:
return JsonResponse(result)
def create_dst_pop(request):
modal_title = request.GET.get("modal_title")
router_id = request.GET.get("router_id")
netnodeip = request.GET.get("netnodeip")
control = ControlEngine(request.session.get("ctrl_header"))
result_interfaces = control.get_route_devices("qrouter-" + router_id,
netnodeip)
if result_interfaces.get("success"):
interfaces = result_interfaces["success"].get("result")
else:
interfaces = []
return render(request, "service/routing/dst_create_modal.html", {
"modal_title": modal_title,
"interfaces": interfaces
})
def execChaining(request, service_id):
if request.is_ajax() and request.method == 'POST':
ctrl_header = request.session.get('ctrl_header')
order = request.POST.get("order")
sfc_id = request.POST.get("sfc_id")
control = ControlEngine(ctrl_header)
result = {}
if order == 'pause':
result = control.pause_sfc(service_id, sfc_id)
elif order == 'resume':
result = control.resume_sfc(service_id, sfc_id)
elif order == 'delete':
result = control.delete_sfc(service_id, sfc_id)
return JsonResponse(result)
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 updateService(request, service_id):
"""
서비스 수정
:param request:
:param service_id:
:return:
"""
if request.is_ajax() and request.method == 'POST':
service_template = json.loads(request.POST.get("service_templates"))
service_template["description"] = unicode(
service_template.get("description"))
dataDic = request.POST.get("mapData")
# logger.info(dataDic)
control = ControlEngine(request.session.get("ctrl_header"))
result = control.update_service(service_template, service_id)
if result.get("success"):
# service_info = result["success"]
result["success"]["update_map"] = control.update_map(
service_id, dataDic.replace('\\', ''))
# 관리포탈 동기화용
# conn = SOAControlDBConnector.getInstance()
# params = (request.session.get("domain_name"), request.session.get("project_name"))
# if len(conn.select(SELECT_SOAC_PROJECT, params)) >= 1:
# params = (
# service_info.get("name"),
# service_info.get("status"),
# request.session.get("domain_name"),
# request.session.get("project_name"),
# service_id,
# )
# try:
# from pprint import pprint
# TODO: 관리포탈 전용
# print "=============params============="
# pprint(params)
# delete_service = conn.delete(DELETE_SOA_SERVICE, params)
# print "================result================ ", delete_service
# temp = {"success": {"message": "서비스삭제", "title": "성공"}}
# except Exception as e:
# temp = {"error": {"message": str(e), "title": "error"}}
# 동기화용 끝
return JsonResponse(result)
def create_src_routing(request, router_id):
control = ControlEngine(request.session.get("ctrl_header"))
data = json.loads(request.POST.get("data"))
netnodeip = request.POST.get("netnodeip")
create_type = request.POST.get("type")
if create_type == "type1":
type1 = {
"type": "type1",
"src": data.get("src"),
"pbr": data.get("pbr")
}
result_pbr_tables = control.get_route_pbr_tables()
if result_pbr_tables.get("success") and result_pbr_tables[
"success"].get("result") and len(
result_pbr_tables["success"]["result"]) > 0:
pbr_tables = result_pbr_tables["success"].get("result")[0].get(
"routers").get("qrouter-" + router_id)
for value in pbr_tables:
if type1["pbr"] == value.get("PBR_TABLE"):
return JsonResponse({
"error": {
"message": "exist pbr_table name: " + type1["pbr"],
"title": "exist pbr_table name"
}
})
result = control.create_route_src_rule_path("qrouter-" + router_id,
netnodeip, type1)
elif create_type == "type2":
type2 = {
"type": "type2",
"dest": data.get("dest"),
"via": data.get("via"),
"dev": data.get("dev"),
"pbr": data.get("pbr")
}
result = control.create_route_src_rule_path("qrouter-" + router_id,
netnodeip, type2)
else:
result = {"error": {"message": "not support", "title": ""}}
return JsonResponse(result)
def saveChaining(request, service_id):
if request.is_ajax() and request.method == 'POST':
sfc_name = request.POST.get("sfc_name")
sfc_desc = request.POST.get("sfc_desc")
fc_list = json.loads(request.POST.get("fc_list"))
sfg_list = json.loads(request.POST.get("sfg_list"))
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')
ctrl_header = request.session.get('ctrl_header')
# print "=========================createSFC()=============================="
# print "=========================fc_list=============================="
# pprint.pprint(fc_list)
# print "=========================sfg_list=============================="
# pprint.pprint(sfg_list)
control = ControlEngine(ctrl_header)
sfc_template = {}
sfc_template["service_function_group_list"] = sfg_list
sfc_template["flow_classifier_list"] = fc_list
sfc_template["sfc_name"] = sfc_name
sfc_template["sfc_desc"] = sfc_desc
result = control.create_sfc(service_id, sfc_template)
if result.get("NeutronError"):
result = {
"error": {
"message": result["NeutronError"]["message"],
"title": result["NeutronError"]["type"]
}
}
# print "=========================result=============================="
# pprint.pprint(result)
# if result.get('success'):
# result['success']['chain_id']
# else:
# {"error":{'message':""}}
# {'success':{'id':"",'chain_id':""}}
return JsonResponse(result)
def detailService(request, service_id):
token = request.session.get('passToken')
ctrl_header = request.session.get("ctrl_header")
if request.method == "POST" and request.is_ajax():
control = ControlEngine(ctrl_header)
# control = ControllerEngine() # TODO: debugging용
service = control.get_service(service_id)
return JsonResponse(service)
else:
if not token:
response = redirect(
"/dashboard/domains/?next=/dashboard/telemeter/metering/" +
service_id)
else:
control = ControlEngine(ctrl_header)
service = control.get_service(service_id)
if service.get("success"):
service_detail = service["success"].get("service_detail")
servers = service_detail.get("vm_list")
response = render(request, 'telemeter/info.html', {
"servers": servers,
"service_name": service_detail.get("name")
})
else:
response = render(request, 'telemeter/info.html',
{"error": service})
logger.info("detailService_end")
return response
def list_service(request):
"""
서비스 목록 페이지
:param request:
:return:
"""
if request.method == 'POST':
logger.info("listService_ajax")
control = ControlEngine(request.session.get("ctrl_header"))
# TODO: 알람을 위해 가데이터 받아오기
# control = ControllerEngine() # TODO: debugging 용
service_list = control.get_service_list()
logger.info("listService_ajax_end")
return JsonResponse(service_list)
else:
token = request.session.get('passToken')
if not token:
return redirect("/dashboard/domains/?next=/dashboard/service")
logger.info("listService_end")
if request.GET.get("error_msg_list"):
error_msg_list = request.GET.get("error_msg_list")
return render(request, 'service/index.html',
{"error_msg_list": error_msg_list})
return render(request, 'service/index.html', {})
def list_routing(request, router_id):
"""
dst_rules, pbr_tables{src_rules}
:param request:
:param router_id:
:return:
"""
control = ControlEngine(request.session.get("ctrl_header"))
modal_title = request.GET.get("modal_title")
dst_rules = control.get_route_dst_rule_list()
result = {"modal_title": modal_title, "router_id": router_id}
if dst_rules.get("success"):
netnodeip = [
tmp_dst_rule.get("netnodeip")
for tmp_dst_rule in dst_rules["success"]["result"]
if tmp_dst_rule.get("router") == "qrouter-" + router_id
]
if len(netnodeip) > 0:
pbr_table_name = router_id.split("-")[0]
result["pbr"] = pbr_table_name
result["netnodeip"] = netnodeip[0]
dst_rule = control.get_route_dst_rule("qrouter-" + router_id,
netnodeip[0])
if dst_rule.get("success"):
result["dst_rules"] = dst_rule["success"].get("result")
result_pbr_tables = control.get_route_pbr_tables()
if result_pbr_tables.get("success") and result_pbr_tables[
"success"].get("result") and len(
result_pbr_tables["success"]["result"]) > 0:
pbr_tables = result_pbr_tables["success"].get("result")[0].get(
"routers").get("qrouter-" + router_id)
result["pbr_tables"] = []
for value in pbr_tables:
# logger.debug("\t\t\n{}\t\t\n{}\t\t\n{}".format(pbr_table_name, value.get("PBR_TABLE"),pbr_table_name in value.get("PBR_TABLE")))
if pbr_table_name in value.get(
"PBR_TABLE"
): # value.get("PBR_TABLE") in ["local", "main", "default"] or
pbr_table = {
"PBR_TABLE": value.get("PBR_TABLE"),
"order": value.get("order"),
"target": value.get("target")
}
src_rules = control.get_route_src_rules(
"qrouter-" + router_id, netnodeip[0],
value.get("PBR_TABLE"))
if src_rules.get("success"):
pbr_table["src_rules"] = src_rules["success"].get(
"result")
result["pbr_tables"].append(pbr_table)
return render(request, "service/routing/index.html", result)
def sync(request, network_id):
token = request.session.get('passToken')
auth_url = request.session.get("auth_url")
neutron = NeutronRestAPI(auth_url, token)
service_id = request.POST.get("service_id")
from sdsecgui.db.soa_db_connector import SOAManagerDBConnector
from sdsecgui.tools.ctrlengine import ControlEngine
control = ControlEngine(request.session.get("ctrl_header"))
try:
m_conn = SOAManagerDBConnector.getInstance()
m_conn.insert_network(auth_url, control, neutron, service_id,
network_id)
result = True
except Exception as e:
from sdsec.settings import logger
logger.debug(e.message)
result = False
return JsonResponse({"result": result})
def insert_service_resource(self, params, service_template, request):
auth_url = params[0]
service_id = params[2]
token = request.session.get("passToken")
ctrl_header = request.session.get("ctrl_header")
neutron = NeutronRestAPI(auth_url, token)
nova = NovaRestAPI(auth_url, token)
glance = GlanceRestAPI(auth_url, token)
cinder = CinderRestAPI(auth_url, token)
control = ControlEngine(ctrl_header)
# router
routers = service_template.get("vrouter_list")
for router in routers:
self.insert_router(auth_url, neutron, service_id,
router.get("vrouter_id"))
# network
networks = service_template.get("network_list")
for network in networks:
self.insert_network(auth_url, control, neutron, service_id,
network.get("network_id"))
# server
servers = service_template.get("vm_list")
for server in servers:
self.insert_server(auth_url, nova, service_id, server.get("vm_id"),
glance)
# volume
volumes = service_template.get("volume_list")
for volume in volumes:
self.insert_volume(auth_url, cinder, service_id,
volume.get("volume_id"))
def login_soa(request):
data = None
try:
data = json.loads(request.POST.get("data"))
except ValueError as e:
result = {
"error": {
"title": e.message,
"message": "json malformed error"
}
}
else:
auth_url = data.get("auth_url")
user_name = data.get("user_name")
password = data.get("pass")
project_name = data.get("project_name")
soac_conn = SOAControlDBConnector.getInstance()
if auth_url == request.session.get("auth_url"):
domain_name = request.session.get("domain_name")
else:
domain = soac_conn.select_one(SELECT_SOAC_DOMAINS, auth_url)
domain_name = domain.get("domain_name")
token = None
roles = None
roles_str = None
project_id = None
user_id = None
keystone = None
# =================================Scope Login==================================
result = KeystoneRestAPI.get_token(auth_url, user_name, password,
domain_name, project_name)
# if type(result) == str:
# result = ast.literal_eval(result) # str 타입을 dictionary 타입으로 바꿈
if result.get('success'):
user = result["success"].get("user")
domain_id = user["domain"].get("id")
if not roles:
roles = result["success"].get("roles")
request.session["domain_id"] = domain_id
token = result['success']['token']
user_id = user.get("id")
if keystone is None:
keystone = KeystoneRestAPI(auth_url, token)
keystone.update_token(token)
roles_str = ','.join(role.get("name") for role in roles)
ctrl_engine = ControlEngine(token=token,
project_id=project_id,
project_name=project_name,
user_id=user_id,
user_name=user_name,
roles=roles_str,
auth_url=auth_url)
request.session["ctrl_header"] = ctrl_engine.get_header()
# ================================================
request.session["passToken"] = token
request.session["user_name"] = user_name
request.session["domain_name"] = domain_name
request.session["project_name"] = project_name
request.session["auth_url"] = auth_url
if roles_str:
request.session["roles"] = roles_str
else:
request.session["roles"] = None
if user_id:
request.session["user_id"] = user_id
if project_id:
request.session["project_id"] = project_id
return result, data
def get_alarm_list(request):
"""
:param request:
:return: {
u'alarm_actions': [
u'http://192.168.10.25:8080/alarm'
],
u'project_id': u'227c72fcda1241b59b1241548649700c',
u'ok_actions': [],
u'이름 name': u'InstanceStatusAlarm',
u'생성일 - 9시간 timestamp': u'2017-07-20T04:17:29.392703',
u'설명 description': u'An event alarm kkkk',
u'time_constraints': [],
u'enabled': True,
u'state_timestamp': u'2017-07-20T04:17:29.392703',
u'이름에 링크 주소 alarm_id': u'0f276622-a037-4b9d-b7af-3014b52352f2',
u'state': u'ok',
u'insufficient_data_actions': [u'http://192.168.10.25:8080/nodata'],
u'repeat_actions': False,
u'user_id': u'f266e9e2e0fe43dfb2f9492851d470cd',
u'event_rule': {
u'query': [
{
u'field': u'traits.instance_id',
u'type': u'string',
u'value': u'9d3f7a1a-fd78-43d3-8294-5ae0789bf76e',
u'op': u'eq'
}, {
u'field': u'traits.state',
u'type': u'string',
u'임계값1 value': u'error',
u'임계값2 op': u'eq'
}
],
u'타입1 event_type': u'compute.instance.update'
},
u'type': u'event',
u'severity': u'moderate'
}
"""
domain_name = request.session.get("domain_name")
description = request.session.get("description")
token = request.session.get('passToken')
project_id = request.session.get('project_id')
auth_url = request.session.get("auth_url")
ctrl_header = request.session.get("ctrl_header")
control = ControlEngine(ctrl_header)
aodh = AodhRestAPI(auth_url, token)
query = {
"query": [
{
"field": "project",
"op": "eq",
"value": project_id
},
]
}
if request.method == 'GET':
service_id = request.GET.get("service_id")
else:
service_id = request.POST.get("service_id")
result_vms = control.get_service_vm(service_id)
result_alarms = aodh.get_alarm_list(query)
alarm_list = []
if result_vms.get("success") and result_alarms.get("success"):
for alarm in result_alarms["success"]:
for vm in result_vms["success"].get("vm_list"):
if vm.get("vm_id") in alarm["threshold_rule"]["query"][0]["value"] or "image" in alarm["threshold_rule"]["meter_name"]:
alarm_list.append(alarm)
# try:
# pass
# for alarm in alarmList:
# queryList = alarm.event_rule.get("query")
# alarm.event_rule["target"] = filter(lambda x: x.get("field") in targetList, queryList)[0] # TODO: 우선 instance만
# threshold = filter(lambda x: x.get("field") in meterNameList, queryList)[0]
# alarm.event_rule["target"]["meter_name"] = threshold.get("field") # TODO: 전부 넣어야함 memory등등
# alarm.event_rule["target"]["op"] = threshold.get("op")
# alarm.event_rule["target"]["threshold"] = threshold.get("value")
# del alarm.event_rule["target"]["type"]
# del alarm.event_rule["query"]
# except Unauthorized as e:
# request.session["error"] = {"title":e.message, "message":e.details}
# if request.method == 'POST':
# return JsonResponse({"error":{"title":e.message, "message":e.details}})
# else:
# request.session["error"] = {"title": e.message, "message": e.details, "code":401}
# return redirect("/dashboard/login/?auth_url=" + auth_url + "&domain_name=" + domain_name + "&description=" + description)
if request.method == 'POST':
return JsonResponse({"success": {'alarmList': alarm_list}})
else:
token = request.session.get('passToken')
if not token:
return redirect("/dashboard/domains/?next=/dashboard/telemeter/alarms")
return render(request, 'telemeter/alarms/index.html', {"alarmList": alarm_list})
def common_login(request,
auth_url,
user_name,
password,
domain_name,
project_name=None):
available_projects = None
token = None
roles = None
roles_str = None
project = None
user = None
keystone = None
domain_id = None
# =================================UnScope Login==================================
if not project_name:
result = KeystoneRestAPI.get_token(auth_url, user_name, password,
domain_name)
if result.get("success"):
# request.session.set_expiry(SESSION_COOKIE_AGE)
token = result['success'].get('token')
roles = result["success"].get("roles")
user = result["success"].get("user")
if user:
user_name = user.get("name")
keystone = KeystoneRestAPI(auth_url, token)
available_projects = keystone.get_available_project_scopes()
# =================================Default 프로젝트==================================
if result["success"].get("project"):
project = result["success"].get("project")
# =================================접근 가능 프로젝트==================================
if not project and available_projects.get("success"):
if not available_projects["success"].get("projects"):
return {
"error": {
"title": "Forbidden",
"message": "모든 프로젝트에 접근 권한이 없습니다."
}
}
else:
project = available_projects["success"].get("projects")[0]
if project:
project_name = project.get("name")
# =================================Scope Login==================================
result = KeystoneRestAPI.get_token(auth_url, user_name, password,
domain_name, project_name)
# logger.info("""################## Scope Login ############
# auth_url: {}
# user_name: {}
# password: {}
# domain_name: {}
# project_name: {}
# result: {}""".format(auth_url, user_name, password, domain_name, project_name, result))
if result.get('success'):
request.session["domain_admin"] = False
# request.session.set_expiry(SESSION_COOKIE_AGE)
token = result['success'].get('token')
user = result["success"].get("user")
domain_id = user["domain"].get("id")
roles = result["success"].get("roles")
project = result["success"].get("project")
request.session["project_id"] = project.get("id")
request.session["project_name"] = project.get("name")
if not keystone:
keystone = KeystoneRestAPI(auth_url, token)
keystone.update_token(token)
if not available_projects:
available_projects = keystone.get_available_project_scopes()
request.session["available_projects"] = [{
"name":
available_project.get("name"),
"id":
available_project.get("id")
} for available_project in available_projects["success"].get(
"projects")]
if roles:
roles_str = ','.join(role.get("name") for role in roles)
elif user.get("name") == 'admin':
roles_str = user.get("name")
ctrl_engine = ControlEngine(token=token,
project_id=project.get("id"),
project_name=project.get("name"),
user_id=user.get("id"),
user_name=user_name,
roles=roles_str,
auth_url=auth_url)
request.session["ctrl_header"] = ctrl_engine.get_header()
# ================================================
request.session["passToken"] = token
request.session["user_name"] = user_name
request.session["domain_name"] = domain_name
request.session["auth_url"] = auth_url
request.session["domain_id"] = domain_id
request.session["roles"] = roles_str
if user:
request.session["user_id"] = user.get("id")
else:
request.session["user_id"] = None
if not project:
request.session["project_id"] = None
request.session["project_name"] = None
return result
def getServerListInService(request, service_id):
"""
해당 서비스의 서버 리스트
:param request:
:param service_id:
:return:
"""
control = ControlEngine(request.session.get("ctrl_header"))
# control = ControllerEngine() # TODO: debugging 용
vm_list = control.get_service_vm(service_id)
if vm_list.get("success"):
auth_url = request.session.get("auth_url")
token = request.session.get("passToken")
stack_id = vm_list.get("success").get("stack_id")
# stack_name = vm_list.get("success").get("service_detail").get("name")
nova = NovaRestAPI(auth_url, token)
result_servers = nova.get_server_detail_list(
fields=["id", "name", "metadata"])
if result_servers.get("success"):
servers = [
result_server
for result_server in result_servers["success"].get("servers")
if result_server.get("metadata")
and result_server["metadata"].get("metering.stack") == stack_id
]
for temp_server in servers:
server = {
"vm_name": temp_server.get("name"),
"vm_id": temp_server.get("id"),
"addresses": [],
}
for network_name, network in temp_server.get(
"addresses").items():
for address in network:
server["addresses"].append(address.get("addr"))
vm_list["success"]["vm_list"].append(server)
else:
vm_list = result_servers
# heat = HeatRestAPI(auth_url, token)
# result = heat.get_resource_in_stack(stack_name, stack_id, {"type": "OS::Heat::AutoScalingGroup"})
# if result.get("success"):
# as_groups = result["success"].get("resources")
# nova = NovaRestAPI(auth_url, token)
# for as_group in as_groups:
# asg_stack_id = as_group.get("physical_resource_id")
# result = heat.find_server_in_autoscaling(asg_stack_id)
# if result.get("success"):
# asg_stack_resources = result["success"]["resources"]
# for asg_stack_resource in asg_stack_resources:
# server_name = "." + asg_stack_resource.get("logical_resource_id") + "."
# result_servers = nova.get_server_detail_list({"name": server_name})
# if result_servers.get("success"):
# servers = result_servers["success"].get("servers")
# for temp_server in servers:
# server = {
# "vm_name": temp_server.get("name"),
# "vm_id": temp_server.get("id"),
# "addresses": [],
# }
# for network_name, network in temp_server.get("addresses").items():
# for address in network:
# server["addresses"].append(address.get("addr"))
# vm_list["success"]["vm_list"].append(server)
return JsonResponse(vm_list, safe=False)
def synchronize_soam(request, service_info, data_dic):
# 관리포탈 동기화용
conn = SOAControlDBConnector.getInstance()
user_name = request.session.get("user_name")
# 도메인명, 프로젝트 아이디, 서비스 아이디, 서비스명, 서비스 상태,
# 동기화 상태{동기화전 I, 동기화중 S, 동기화완료 C, 동기화실패 F}, 동기화 날짜
auth_url = request.session.get("auth_url")
project_id = request.session.get("project_id")
params = (auth_url, project_id, service_info.get("service_id"),
service_info.get("name"), service_info.get("status"), user_name,
user_name)
logger.debug("[soac db insert service for sync]")
# conn.insert(INSERT_SOAC_SERVICE, params) # sync를 위해 soacDB에 넣기
control = ControlEngine(request.session.get("ctrl_header"))
s_result = control.get_service(service_info.get("service_id"))
if s_result.get("success"):
# used_security_group_list 상세정보 조회, security_group_list 생성
select_security_groups = conn.select(
SELECT_SECURITY_RESOURCE_GROUP_LIST)
security_groups = data_dic.get("used_security_group_list")
security_group_list = []
for security_group in security_groups:
for select_security_group in select_security_groups:
if select_security_group.get(
"security_id") == security_group.get("security_id"):
select_security_group[
"security_type"] = security_group.get("security_type")
security_group_list.append(select_security_group)
m_conn = SOAManagerDBConnector.getInstance()
# security_group
# TODO: seccurity_type => 관리포탈에서 코드조회후 코드로 넣을것
# TODO: manufacture_icon
# TODO: 보안장비가 이미 등록되 있을시 무시
for security_group in security_group_list:
params = (security_group.get("security_type"),
security_group.get("security_name"),
security_group.get("security_icon"),
security_group.get("manufacture_name"),
security_group.get("manufacture_icon"),
security_group.get("software_version"),
security_group.get("description"))
logger.debug("[soam db insert equipment]")
m_conn.insert(INSERT_SOAM_EQUIPMENT, params)
params = (auth_url, project_id, service_info.get("service_id"),
service_info.get("name"),
service_info.get("service_description"))
logger.debug("[soam db insert service]")
m_conn.insert_service(params, data_dic)
scheduler = Scheduler()
def check_service_status():
logger.debug("[check service status]")
create_status = False
# 서비스 상태 확인
result = control.get_service(service_info.get("service_id"))
if result.get("success"):
try:
service_template = result["success"].get("service_detail")
# 생성중이면 1분뒤 다시 확인
if service_template.get("status") == "CREATE_IN_PROGRESS":
logger.debug("[wait CREATE_IN_PROGRESS]")
return
# 생성 완료면 자원 데이터 저장
elif service_template.get("status") == "CREATE_COMPLETE":
logger.debug("[soam db insert resources]")
params = (auth_url, project_id,
service_info.get("service_id"),
service_info.get("name"),
service_info.get("service_description"))
m_conn.insert_service_resource(params,
service_template,
request)
# 생성 실패면
else:
pass
# 생성 완료 or 실패 시 soac db 수정
logger.debug("[soac db update service for sync complete]")
# params = (service_template.get("name"), service_template.get("status"), "C", user_name, auth_url,
# request.session.get("project_name"), service_info.get("service_id"))
# conn.update(UPDATE_SOAC_SERVICE, params)
scheduler.kill_scheduler("check_service")
except Exception as e:
error_str = """
Title: {}
Traceback: {}
""".format(e.message,
traceback.format_exc().strip())
logger.error(error_str)
scheduler.kill_scheduler("check_service")
else:
scheduler.kill_scheduler("check_service")
logger.debug("[wait CREATE_IN_PROGRESS]")
scheduler.schedule_interval(check_service_status,
"check_service",
seconds=30)
def detail_service(request, service_id):
"""
서비스 상세조회
:param request:
:param service_id:
:return:
"""
token = request.session.get("passToken")
auth_url = request.session.get("auth_url")
if request.method == 'POST':
logger.info("detailServicePOST")
control = ControlEngine(request.session.get("ctrl_header"))
# control = ControllerEngine() # TODO: debugging 용
service_detail, map_data = control.get_service_detail_and_link_list(
service_id)
public_network = []
logger.info("detailServicePOST_end_public_network")
try:
neutron = NeutronRestAPI(auth_url, token)
result = neutron.get_network_list({"router:external": True})
except Exception as e:
logger.warning("get public_network fail" + str(e))
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"):
# print service_detail["success"], map_data, public_network
jsonDic = {
"success": service_detail["success"],
"links": {},
"security_types": {},
"public_network": public_network
}
template = control.get_template(service_id)
if template.get("success"):
user_template = template["success"].get("user_template")
if user_template:
# print "user_template: {}\nservice_id: {}".format(user_template, service_id)
user_template["service_id"] = service_id
jsonDic["success"]["template"] = user_template
else:
jsonDic.get("success").get("service_detail").get(
"error_msg_list").push(template.get("error"))
if map_data.get("success"):
map_link_list = map_data["success"].get("map_link_list")
if map_link_list:
jsonDic["links"] = map_link_list.get("links")
jsonDic["asLinks"] = map_link_list.get("asLinks")
jsonDic["security_types"] = map_link_list.get(
"security_types")
jsonDic["used_security_group_list"] = map_link_list.get(
"used_security_group_list")
# request.session["service_dic"] = jsonDic
return JsonResponse(jsonDic)
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 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
