def get_router_list(request): # logger.info("get_router_list") token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == 'POST': try: keystone = KeystoneRestAPI(auth_url, token) result_projects = keystone.get_project_list() projects = [] if result_projects.get("success"): projects = result_projects["success"].get("projects") neutron = NeutronRestAPI(auth_url, token) result = neutron.getRouterList() if result.get("success"): for router in result["success"].get("routers"): if router.get("tenant_id"): for project in projects: if project.get("id") == router.get("tenant_id"): router["project_name"] = project.get("name") except Unauthorized as e: result = { "error": { "title": e.message, "message": e.details, "code": 401 } } return JsonResponse(result) else: token = request.session.get('passToken') if not token: return redirect( "/dashboard/domains/?next=/dashboard/admin/routers") return render(request, 'admin/routers/index.html', {})
def sync_modal(request, network_id): token = request.session.get('passToken') auth_url = request.session.get("auth_url") neutron = NeutronRestAPI(auth_url, token) result = neutron.get_network(network_id) return render(request, 'admin/sync_modal.html', {'data': result["success"]["network"]})
def retrieve_agent_list(request): if request.is_ajax() and request.method == 'POST': token = request.session.get('passToken') auth_url = request.session.get("auth_url") neutron = NeutronRestAPI(auth_url, token) agent_list = neutron.getAgentList().get("success").get("agents") return JsonResponse({"success": {'agentList': agent_list}})
def get_interface_list_in_router(request, router_id): token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == 'POST': neutron = NeutronRestAPI(auth_url, token) ports = neutron.get_port_list({ "device_id": router_id }).get("success").get("ports") # interfaceList = get_interface_list_in_router(router_id) return JsonResponse({"success": {'interface': ports}})
def sync_modal(request, router_id): token = request.session.get('passToken') auth_url = request.session.get("auth_url") neutron = NeutronRestAPI(auth_url, token) result = neutron.getRouter(router_id) interfaces = neutron.get_port_list({"device_id": router_id}) if interfaces.get("success") and result.get("success"): result["success"]["router"]["interfaces"] = interfaces.get( "success").get("ports") return render(request, 'admin/sync_modal.html', {'data': result["success"]["router"]})
def ports_modal(request): auth_url = request.session.get("auth_url") token = request.session.get("passToken") port_id = request.GET.get("port_id") data = {"modal_title": request.GET.get("modal_title")} if port_id: neutron = NeutronRestAPI(auth_url, token) result = neutron.getPort(port_id) if result.get("success"): data["port"] = result["success"].get("port") return render(request, 'admin/networks/ports/modal.html', data)
def create_modal(request): token = request.session.get('passToken') auth_url = request.session.get("auth_url") modal_title = request.GET.get("modal_title") instance_id = request.GET.get("instance_id") data = { "modal_title": modal_title, } nova = NovaRestAPI(auth_url, token) neutron = NeutronRestAPI(auth_url, token) glance = GlanceRestAPI(auth_url, token) availability_zone = nova.get_availability_zone() if availability_zone.get("success"): data["availabilityZoneInfo"] = availability_zone["success"].get("availabilityZoneInfo") images = glance.get_image_list() if images.get("success"): data["images"] = images["success"].get("images") flavors = nova.get_flavor_detail_list() if flavors.get("success"): data["flavors"] = flavors["success"].get("flavors") networks = neutron.get_network_list() if networks.get("success"): data["networks"] = networks["success"].get("networks") subnets = neutron.get_subnet_list() if subnets.get("success"): # network["subnets"]에 id만 있어 해당 아이디의 subnet을 찾아 name으로 대체 subnet_list = subnets["success"].get("subnets") for network in data["networks"]: network["subnets"] = [ subnet.get("name") for subnet_id in network["subnets"] for subnet in subnet_list if subnet.get("id") == subnet_id ] ports = neutron.get_port_list() if ports.get("success"): data["ports"] = ports["success"].get("ports") if instance_id: # 수정 시 data["instance_id"] = instance_id result = nova.get_server(instance_id) if result.get("success"): server = result["success"].get("server") data["server"] = server return render(request, 'admin/instances/modal.html', data)
def get_network_list(request): # logger.info("get_network_list") token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == "GET": if not token: return redirect( "/dashboard/domains/?next=/dashboard/admin/networks") neutron = NeutronRestAPI(auth_url, token) query = {} if request.method == "GET" and request.GET.get("project_id"): query["tenant_id"] = request.GET.get("project_id") elif request.method == "POST" and request.POST.get("project_id"): query["tenant_id"] = request.POST.get("project_id") result = neutron.get_network_list(q=query) if result.get("success"): keystone = KeystoneRestAPI(auth_url, token) projects = keystone.get_project_list(fields={"fields": ["id", "name"]}) subnets = neutron.get_subnet_list(fields=["id", "name", "cidr"]) for network in result["success"].get("networks"): # project id로 project_name 추가 if projects.get("success"): for project in projects["success"].get("projects"): if project.get("id") == network.get("tenant_id"): network["project_name"] = project.get("name") # project id로 project_name 추가끝 # subnet id로 subnetList 추가 if subnets.get("success"): network["subnets"] = [ subnet for subnet_id in network.get("subnets") for subnet in subnets["success"].get("subnets") if subnet.get("id") == subnet_id ] # subnet id로 subnetList 추가끝 result = result.get("success") if request.is_ajax(): return JsonResponse(result) else: if request.method == "GET": try: soam_sync = bool( config.get("SETTINGS", "PORTAL_SYNC") == "True") except Exception as e: soam_sync = False result["sync"] = soam_sync # TODO: soam sync delete return render(request, 'admin/networks/index.html', result)
def actionPort(request, port_id, action): token = request.session.get('passToken') domain_name = request.session.get("domain_name") project_name = request.session.get("project_name") auth_url = request.session.get("auth_url") if request.method == 'POST': try: neutron = NeutronRestAPI(auth_url, token) if action == "detail": result = neutron.getPort(port_id) elif action == "update": data = json.loads(request.POST.get("data")) result = neutron.updatePort(port_id, data) elif action == "delete": result = neutron.delete_port(port_id) else: result = { "error": { "title": "Not Found", "message": "지원하지 않는 기능입니다.", "code": 404 } } except Unauthorized as e: result = { "error": { "title": e.message, "message": e.details, "code": 401 } } return JsonResponse(result) else: if not token: return redirect( "/dashboard/domains/?next=/dashboard/admin/networks/ports/" + port_id) if action == "detail": return render(request, 'admin/networks/ports/info.html', {'port_id': port_id})
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 create_subnet(request): token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == 'POST': data = json.loads(request.POST.get("data")) try: neutron = NeutronRestAPI(auth_url, token) result = neutron.createSubnet(data) except Unauthorized as e: result = { "error": { "title": e.message, "message": e.details, "code": 401 } } return JsonResponse(result)
def get_subnet_list(request): token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == 'POST': try: neutron = NeutronRestAPI(auth_url, token) fields = ["name", "id"] result = neutron.get_subnet_list(fields=fields) except Unauthorized as e: result = { "error": { "title": e.message, "message": e.details, "code": 401 } } return JsonResponse(result)
def delete_network(request, network_id): # logger.info("delete_network") token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == 'POST': try: neutron = NeutronRestAPI(auth_url, token) result = neutron.deleteNetwork(network_id) return JsonResponse(result) except Unauthorized as e: result = { "error": { "title": e.message, "message": e.details, "code": 401 } } return JsonResponse(result)
def get_metadata_for_create_router(request): token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == 'POST': try: neutron = NeutronRestAPI(auth_url, token) q = {"router:external": True} fields = ["id", "name"] result = neutron.get_network_list(q, fields) except Unauthorized as e: result = { "error": { "title": e.message, "message": e.details, "code": 401 } } return JsonResponse(result)
def subnet_modal(request, subnet_id=None): data = {"modal_title": request.GET.get("modal_title")} auth_url = request.session.get("auth_url") token = request.session.get('passToken') if subnet_id: try: neutron = NeutronRestAPI(auth_url, token) result = neutron.get_subnet(subnet_id) if result.get("success"): subnet = result["success"].get("subnet") allocation_pools_str = "" for idx, allocation_pool in enumerate( subnet.get("allocation_pools")): if idx != 0: allocation_pools_str += "\n" allocation_pools_str += allocation_pool.get( "start") + ", " + allocation_pool.get("end") subnet["allocation_pools"] = allocation_pools_str dns_nameservers_str = "\n".join(subnet.get("dns_nameservers")) subnet["dns_nameservers"] = dns_nameservers_str host_routes_str = "" for idx, host_route in enumerate(subnet.get("host_routes")): if idx != 0: host_routes_str += "\n" host_routes_str += host_route.get( "destination") + ", " + host_route.get("nexthop") subnet["host_routes"] = host_routes_str data["subnet"] = subnet except Unauthorized as e: return JsonResponse({ "error": { "title": e.message, "message": e.details, "code": 401 } }) return render(request, 'admin/networks/subnets/modal.html', data)
def get_network(request, network_id): if request.method == 'GET' and request.is_ajax(): # logger.info("get_network") token = request.session.get('passToken') auth_url = request.session.get("auth_url") neutron = NeutronRestAPI(auth_url, token) result = neutron.get_network(network_id) if result.get("success"): network = result["success"].get("network") # subnet id로 subnetList 추가 subnets = [] for subnet_id in network.get("subnets"): subnet = neutron.get_subnet(subnet_id) if subnet.get("success"): subnets.append(subnet.get("success").get("subnet")) network["subnets"] = subnets # subnet id로 subnetList 추가끝 # network id로 portList 추가 ports = neutron.get_port_list({"network_id": network.get("id")}) if ports.get("success"): network["ports"] = ports.get("success").get("ports") # network id로 portList 추가끝 dhcpAgents = neutron.getDHCPAgentHostingNetworkList(network_id) if dhcpAgents.get("success"): network["dhcpAgents"] = dhcpAgents.get("success").get("agents") return render(request, 'admin/networks/info.html', {'network': network}) return JsonResponse(result) else: return redirect("/dashboard/admin/networks?network_id=" + network_id)
def new_service(request): """ 서비스 생성 페이지 :param request: :return: """ if request.is_ajax() and request.method == 'POST': logger.info("newServicePOST") token = request.session.get("passToken") auth_url = request.session.get("auth_url") logger.info("newServicePOST_end_getpublic_network") neutron = NeutronRestAPI(auth_url, token) result = neutron.get_network_list() if result.get("success"): public_network = filter(lambda network: network["router:external"], result["success"]["networks"]) return JsonResponse({ 'success': { "service_detail": {} }, "public_network": public_network }) else: return JsonResponse(result) else: logger.info("newService_end") token = request.session.get('passToken') if not token: return redirect( "/dashboard/domains/?next=/dashboard/service/new_service") try: soam_sync = bool(config.get("SETTINGS", "PORTAL_SYNC") == "True") except Exception as e: soam_sync = False return render(request, 'service/info.html', {"sync": soam_sync}) # TODO: soam sync delete
def sync(request, router_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 try: m_conn = SOAManagerDBConnector.getInstance() m_conn.insert_router(auth_url, neutron, service_id, router_id) result = True except Exception as e: from sdsec.settings import logger logger.debug(e.message) result = False return JsonResponse({"result": 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 action_router(request, router_id, action): token = request.session.get('passToken') auth_url = request.session.get("auth_url") if request.method == 'POST': try: neutron = NeutronRestAPI(auth_url, token) if action == "detail": result = neutron.getRouter(router_id) interfaces = neutron.get_port_list({"device_id": router_id}) if interfaces.get("success") and result.get("success"): result["success"]["router"]["interfaces"] = interfaces.get( "success").get("ports") elif action == "update": data = json.loads(request.POST.get("data")) result = neutron.updateRouter(router_id, data) elif action == "delete": result = neutron.deleteRouter(router_id) else: result = { "error": { "title": "Not Found", "message": "지원하지 않는 기능입니다.", "code": 404 } } except Unauthorized as e: result = { "error": { "title": e.message, "message": e.details, "code": 401 } } return JsonResponse(result) else: if not token: return redirect( "/dashboard/domains/?next=/dashboard/admin/routers/" + router_id + "/detail") if action == "detail": return render(request, 'admin/routers/info.html', {'router_id': router_id})
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 project_modal(request): token = request.session.get('passToken') auth_url = request.session.get("auth_url") modal_title = request.GET.get("modal_title") project_id = request.GET.get("project_id") domain_id = request.session.get("domain_id") domain_name = request.session.get("domain_name") data = { "modal_title": modal_title, "input_domain_id": domain_id, "input_domain_name": domain_name, "project_id": project_id } keystone = KeystoneRestAPI(auth_url, token) u_result = keystone.get_user_list({"domain_id": domain_id}) if u_result.get("success"): data["users"] = u_result["success"].get("users") g_result = keystone.get_group_list() if g_result.get("success"): data["groups"] = g_result["success"].get("groups") r_result = keystone.get_role_list() if r_result.get("success"): data["roles"] = r_result["success"].get("roles") if project_id: p_result = keystone.get_project(project_id) if p_result.get("success"): project = p_result["success"].get("project") data["project_name"] = project.get("name") data["description"] = project.get("description") data["enabled"] = project.get("enabled") ra_result = keystone.get_role_assignments( {"scope.project.id": project_id}) if ra_result.get("success"): role_assignments = ra_result["success"].get("role_assignments") response_role_assignments = {"users": [], "groups": []} for role_assignment in role_assignments: # role_assignment_role 루프 role_assignment_user = role_assignment.get("user") if role_assignment_user: select_user = filter( lambda user: user.get("id") == role_assignment_user. get("id"), data["users"]) if select_user: role_assignment_user["name"] = select_user[0].get( "name") data["users"][data["users"].index( select_user[0])]["assigned"] = True role_assignment_group = role_assignment.get("group") if role_assignment_group: select_group = filter( lambda group: group.get("id") == role_assignment_group. get("id"), data["groups"]) if select_group: role_assignment_group["name"] = select_group[0].get( "name") data["groups"][data["groups"].index( select_group[0])]["assigned"] = True role_assignment_role = role_assignment.get("role") if role_assignment_role: select_role = filter( lambda role: role.get("id") == role_assignment_role. get("id"), data["roles"]) if select_role: role_assignment_role["name"] = select_role[0].get( "name") if role_assignment_role: if role_assignment_user: select_user = [ user for user in response_role_assignments["users"] if user.get("id") == role_assignment_user.get("id") ] # 이미 있는지 확인 if len(select_user) == 0: # 없으면 만들기 response_role_assignments["users"].append({ "name": role_assignment_user.get("name"), "id": role_assignment_user.get("id"), "roles": [role_assignment_role], "roles_display": role_assignment_role.get("name") }) elif len(select_user) == 1: # 있으면 role 추가 select_user[0]["roles"].append( role_assignment_role) select_user[0][ "roles_display"] += ", " + role_assignment_role.get( "name") if role_assignment_group: select_group = [ group for group in response_role_assignments["groups"] if group.get("id") == role_assignment_group.get("id") ] # 이미 있는지 확인 if len(select_group) == 0: # 없으면 만들기 response_role_assignments["groups"].append({ "name": role_assignment_group.get("name"), "id": role_assignment_group.get("id"), "roles": [role_assignment_role], "roles_display": role_assignment_role.get("name") }) elif len(select_group) == 1: # 있으면 role 추가 select_group[0]["roles"].append( role_assignment_role) select_group[0][ "roles_display"] += ", " + role_assignment_role.get( "name") data["role_assignments"] = response_role_assignments data["role_assignments_json"] = json.dumps( response_role_assignments) nova = NovaRestAPI(auth_url, token) cinder = CinderRestAPI(auth_url, token) neutron = NeutronRestAPI(auth_url, token) result_nova_quota_set = nova.get_quotas(project_id) result_neutron_quotas = neutron.get_quotas(project_id) result_cinder_quotas = cinder.get_cinder_quotas(project_id) # result_cinder_limits = cinder.get_limits(project_id) if result_nova_quota_set.get("success"): nova_quota_set = result_nova_quota_set["success"].get("quota_set") data["nova_quota_set"] = nova_quota_set if result_neutron_quotas.get("success"): neutron_quotas = result_neutron_quotas["success"].get("quota") data["neutron_quotas"] = neutron_quotas # if result_cinder_limits.get("success"): # cinder_limits = result_cinder_limits["success"]["limits"].get("absolute") # data["cinder_limits"] = cinder_limits if result_cinder_quotas.get("success"): cinder_quotas = result_cinder_quotas["success"].get("quota_set") data["cinder_quotas"] = cinder_quotas return render(request, 'identity/projects/modal.html', data)
def index(request): token = request.session.get("passToken") auth_url = request.session.get("auth_url") project_id = request.session.get("project_id") auth = ZabbixRestAPI.get_auth("Admin", "zabbix") zabbix = ZabbixRestAPI(auth) if request.method == "POST" and request.is_ajax(): groupids = request.POST.get("groupids") groupname = request.POST.get("groupname") hostids = request.POST.get("hosts") if groupname or groupids: if "Template" in groupname: if groupname == "Templates": result_hosts = zabbix.get_template(output="extend") else: result_hosts = zabbix.get_template(output="extend", groupids=groupids) else: result_hosts = zabbix.get_hosts(output=["hostid", "host"], groupids=groupids) else: host_ping_list = [] for hostid in json.loads(hostids): result_item = zabbix.get_item({"hostid": hostid, "name": "Agent ping"}, output=["lastvalue"]) if result_item.get("result"): host_ping_list.append({"hostid": hostid, "ping": result_item["result"][0].get("lastvalue")}) result_hosts = {"host_ping_list": host_ping_list} return JsonResponse(result_hosts) else: """ 1. openstack - floating_ip 목록 조회 2. zabbix - host 목록 조회 floating_ip 목록 중 등록되지 않은 vm이 있으면 host 생성(floating_ip-port조회) 3. openstack - vm조회 4. zabbix - hostgroup조회 5. zabbix - host 생성 6. zabbix - hostinterface 조회 7. zabbix - application 생성 8. zabbix - item 생성 9. zabbix - trigger 생성 10. zabbix - mediatype 생성 11. zabbix - action 생성 12. zabbix - host 목록 조회 13. zabbix - hostinterface 조회 floating_ip 목록 중 등록되지 않은 vm이 없거나 생성 완료후 1. host목록, hostinterface목록, vm목록 매칭 2. host목록 반환 """ neutron = NeutronRestAPI(auth_url, token) # openstack의 floating_ip 목록 가져오기 response_data = {"hosts": [], "vm_list": []} q = {"project_id": project_id} result_floating_ips = neutron.get_floating_ips(None, q) create_host_flag = False # host목록 가져오기 result_hosts = zabbix.get_hosts(output=["hostid", "host", "status", "name"]) if result_hosts.get("result") and result_floating_ips.get("success"): floating_ips = result_floating_ips["success"].get("floatingips") # 중요1 hosts = result_hosts.get("result") # floating_ips 목록이 Zabbix에 전부 등록되있는지 확인 # TODO: javascript에서 서버 상태(ICMP Ping)를 실시간으로 변경 recovery_list = [] # 중요3 for floating_ip in floating_ips: if floating_ip.get("port_id"): # floatingip - port 조회 result_port = neutron.getPort(floating_ip["port_id"]) if result_port.get("success"): port = result_port["success"].get("port") floating_ip["port_details"] = port server_id = port.get("device_id") host_names = [temp_host.get("host") for temp_host in hosts] # 각 가상머신의 호스트가 등록되있지 않다면 등록 if server_id and "compute" in port.get("device_owner") and server_id not in host_names: # floatingip - port - device(서버) 조회 recovery_info = { "server": { "vm_id": server_id, "floating_ip_id": floating_ip.get("id"), "floating_ip_address": floating_ip.get("floating_ip_address") }, "auth_url": auth_url, "project_name": request.session.get("project_name") } recovery_list.append(recovery_info) # host의 interface 목록 가져오기 result_host_interfaces = zabbix.get_host_interfaces(output=["hostid", "ip", "port"]) if result_host_interfaces.get("result"): host_interfaces = result_host_interfaces["result"] for host in hosts: for host_interface in host_interfaces: # host와 interface 매칭 if host.get("hostid") == host_interface.get("hostid"): host["interface"] = host_interface # host중 interface의 ip가 127.0.0.1이거나 localhost인 경우 if "127.0.0.1" in host_interface.get("ip") or "localhost" in host_interface.get("ip"): for floating_ip in floating_ips: # floating_ip의 device_id와 host의 host(hostname)이 같을때만 리스트에 담아 보여주기 if floating_ip.get("port_details"): result_item = zabbix.get_item({"hostid": host.get("hostid"), "name": "ICMP ping"}) if result_item.get("result"): item = result_item["result"][0] if host.get("host") == floating_ip["port_details"]["device_id"]: host["floatingip_info"] = floating_ip host["ping"] = item.get("lastvalue") response_data["vm_list"].append(host) # logger.debug("\n\n\n\nfloating_ip: {}\nctrl_header: {}\n\n\n\n".format(floating_ip, request.session.get("ctrl_header"))) else: check_recovered_vm_host(zabbix, host, item, floating_ip) elif "admin" in request.session["roles"]: result_item = zabbix.get_item({"hostid": host.get("hostid"), "name": "Agent ping"}) if result_item.get("result"): host["ping"] = result_item["result"][0].get("lastvalue") response_data["hosts"].append(host) if len(recovery_list) > 0: response_data["synchronize_flag"] = False else: response_data["synchronize_flag"] = True else: response_data["error"] = {} if result_floating_ips.get("error"): response_data["error"]["openstack"] = result_floating_ips["error"] if not result_hosts.get("result"): response_data["error"]["zabbix"] = result_hosts return render(request, "monitoring/index.html", response_data)
def new_service(request): if request.method == "GET": return render(request, "service/intent/new_service.html", {}) elif request.is_ajax() and request.method == 'POST': logger.info("newIntentServicePOST") token = request.session.get("passToken") auth_url = request.session.get("auth_url") domain_name = request.session.get("domain_name") rule_key = request.POST.get("rule_key") neutron = NeutronRestAPI(auth_url, token) result = neutron.get_network_list() if result.get("success"): public_network = filter(lambda network: network["router:external"], result["success"]["networks"]) conn = SOAControlDBConnector.getInstance() # rule params = (domain_name, rule_key) rule = conn.select_one(SELECT_FW_RULE, params) # source target params = (domain_name, rule.get("source_target")) src = conn.select_one(SELECT_ENDPOINT, params) # destination target params = (domain_name, rule.get("destination_target")) dest = conn.select_one(SELECT_ENDPOINT, params) json_param = { "ietf-i2nsf-cfi-policy:policy": { "policy-name": rule.get("policy_name"), "rule": [{ "rule-name": "rule_name", "condition": { "firewall-condition": { "source-target": { "src-target": src.get("name") } }, "custom-condition": { "destination-target": { "dest-target": dest.get("name") } } }, "action": { "primary-action": rule.get("action_data") } }] } } if rule.get("start_time") and rule.get("end_time"): json_param["ietf-i2nsf-cfi-policy:policy"]["rule"][0][ "event"] = { "time-information": { "begin-time": rule.get("start_time"), "end-time": rule.get("end_time") } } # sec_ctrl = SecurityControllerRestAPI() # result = sec_ctrl.get_service_template_by_rule(json_param) # {"nsf_names": ["time_based_firewall", "url_filtering"]} # result = {"nsf_names": ["url_filtering"]} # result = {"nsf_names": ["time_based_firewall", "url_filtering"]} nsf_names = result.get("nsf_names") service_template = conn.select_service_template_by_nsf_names( nsf_names) logger.info("\n\n\n\nservice: {}\n\n\n".format(service_template)) # params = (template_key, domain_name) # security_types = conn.select_one(SELECT_SECURITY_RESOURCE_GROUP_BY_TEMPLATE_KEY, params) link_json = json.loads( service_template.get("link_json").replace("\\", "")) links = link_json.get("links", []) as_links = link_json.get("asLinks", []) resources = link_json.get("resources", []) security_types = link_json.get("security_types", []) json_data = { 'success': { "service_detail": json.loads(service_template.get("topology_json")) }, "asLinks": as_links, "public_network": public_network, "service_template": service_template, "security_types": security_types, "links": links } return JsonResponse(json_data) else: return JsonResponse(result)
def synchronize_floating_server_host(request): if request.method == 'POST' and request.is_ajax(): token = request.session.get("passToken") auth_url = request.session.get("auth_url") project_id = request.session.get("project_id") auth = ZabbixRestAPI.get_auth("Admin", "zabbix") zabbix = ZabbixRestAPI(auth) neutron = NeutronRestAPI(auth_url, token) err_msg_list = [] # openstack의 floating_ip 목록 가져오기 q = {"project_id": project_id} result_floating_ips = neutron.get_floating_ips(None, q) create_host_flag = False # host목록 가져오기 result_hosts = zabbix.get_hosts(output=["hostid", "host", "status", "name"]) if result_hosts.get("result") and result_floating_ips.get("success"): floating_ips = result_floating_ips["success"].get("floatingips") # 중요1 hosts = result_hosts.get("result") # floating_ips 목록이 Zabbix에 전부 등록되있는지 확인 # TODO: zabbix에 등록된 host중 floatingip연결을 해제시키거나 삭제된 server가 있으면 제거 recovery_list = [] # 중요3 for floating_ip in floating_ips: if floating_ip.get("port_id"): # floatingip - port 조회 result_port = neutron.getPort(floating_ip["port_id"]) if result_port.get("success"): port = result_port["success"].get("port") floating_ip["port_details"] = port server_id = port.get("device_id") host_names = [temp_host.get("host") for temp_host in hosts] # 각 가상머신의 호스트가 등록되있지 않다면 등록 중요3 if server_id and "compute" in port.get("device_owner") and server_id not in host_names: # floatingip - port - device(서버) 조회 recovery_info = { "server": { "vm_id": server_id, "floating_ip_id": floating_ip.get("id"), "floating_ip_address": floating_ip.get("floating_ip_address"), "fixed_ips": port.get("fixed_ips") }, "auth_url": auth_url, "project_name": request.session.get("project_name") } recovery_list.append(recovery_info) if result_port.get("error"): err_msg_list.append(result_port["error"]) if len(recovery_list) > 0: # 서비스 리스트 조회 -> 서비스 조회 -> vm_list에서 같은아이디 있는지 확인 ctrl_header = request.session.get("ctrl_header") control = ControlEngine(ctrl_header) result_service_list = control.get_service_list() if result_service_list.get("success"): for service in result_service_list["success"].get("service_list"): service_id = service.get("service_id") result_service = control.get_service(service_id) if result_service.get("success"): for recovery_info in recovery_list: for vm in result_service["success"]["service_detail"].get("vm_list"): # 서비스내에 해당 server가 있는지 확인 if vm.get("vm_id") == recovery_info["server"].get("vm_id"): recovery_info["server"]["vm_name"] = vm.get("vm_name") recovery_info["server"]["service_id"] = service_id if result_service.get("error"): err_msg_list.append(result_service["error"]) if result_service_list.get("error"): err_msg_list.append(result_service_list["error"]) # service_list 조회끝 for recovery_info in recovery_list: logger.debug("\n\n\n\n" + json.dumps(recovery_info) + "\n\n\n\n") # hostgroup 조회 result_hostgroup = zabbix.get_hostgroups({"name": "Linux servers"}, ["groupid"]) if result_hostgroup.get("result"): hostgroup_id = result_hostgroup["result"][0].get("groupid") result_create_host = create_host(request, zabbix, recovery_info, hostgroup_id) if len(result_create_host) < 1: create_host_flag = True else: err_msg_list.append(result_create_host) if not result_hostgroup.get("result"): err_msg_list.append(result_hostgroup) # 호스트 생성시 호스트 목록 다시조회 if create_host_flag: result_hosts = zabbix.get_hosts(output=["hostid", "host", "status", "name"]) if result_hosts.get("result"): hosts = result_hosts["result"] if not result_hosts.get("result"): err_msg_list.append(result_hosts) if result_floating_ips.get("error"): err_msg_list.append(result_floating_ips["error"]) return JsonResponse({"success": {"err_msg_list": err_msg_list}})
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
def update_project(request, project_id): if request.is_ajax() and request.method == 'POST': token = request.session.get('passToken') auth_url = request.session.get('auth_url') project = json.loads(request.POST.get("project")) quota = json.loads(request.POST.get("quotas")) data = { "project": { "description": project.get("description"), "domain_id": project.get("domain_id"), "name": project.get("name"), "enabled": project.get("enabled"), "is_domain": False, } } keystone = KeystoneRestAPI(auth_url, token) result = keystone.update_project(project_id, data) err_msg_list = [] if result.get("success"): assign_list = json.loads(request.POST.get("assignList")) unassign_list = json.loads(request.POST.get("unassignList")) # 사용자 역할 할당 for assign in assign_list.get("users"): user_id = assign.get("user_id") role_id_list = assign.get("role_id_list") for role_id in role_id_list: assign_result = keystone.assign_role_to_user_on_projects( project_id, user_id, role_id) if assign_result.get("error"): if not result.get("error"): result["error"] = [] result["error"].append(assign_result["error"]) # 사용자 역할 제거 for unassign in unassign_list.get("users"): user_id = unassign.get("user_id") role_id_list = unassign.get("role_id_list") for role_id in role_id_list: unassign_result = keystone.unassign_role_to_user_on_projects( project_id, user_id, role_id) if unassign_result.get("error"): if not result.get("error"): result["error"] = [] result["error"].append(unassign_result["error"]) # 그룹 역할 할당 for assign in assign_list.get("groups"): group_id = assign.get("group_id") role_id_list = assign.get("role_id_list") for role_id in role_id_list: assign_result = keystone.assign_role_to_group_on_projects( project_id, group_id, role_id) if assign_result.get("error"): if not result.get("error"): result["error"] = [] result["error"].append(assign_result["error"]) # 그룹 역할 제거 for unassign in unassign_list.get("groups"): group_id = unassign.get("group_id") role_id_list = unassign.get("role_id_list") for role_id in role_id_list: unassign_result = keystone.unassign_role_to_group_on_projects( project_id, group_id, role_id) if unassign_result.get("error"): if not result.get("error"): result["error"] = [] result["error"].append(unassign_result["error"]) if quota["nova"].get("quota_set"): nova = NovaRestAPI(auth_url, token) result = nova.update_quotas(project_id, quota["nova"]) if result.get("error"): err_msg_list.append(result["error"]) if quota["neutron"].get("quota"): neutron = NeutronRestAPI(auth_url, token) result = neutron.update_quotas(project_id, quota["neutron"]) if result.get("error"): err_msg_list.append(result["error"]) if quota["cinder"].get("quota_set"): cinder = CinderRestAPI(auth_url, token) result = cinder.update_quotas(project_id, quota["cinder"]) if result.get("error"): err_msg_list.append(result["error"]) return JsonResponse(result)
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 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