def get_route(self, request, osdf_config): """ This method checks :param logical_link: :return: """ try: routeInfo = request["routeInfo"]["routeRequests"] routeRequest = routeInfo[0] src_access_node_id = routeRequest["srcPort"]["accessNodeId"] dst_access_node_id = routeRequest["dstPort"]["accessNodeId"] dzn_data, initial_start_edge, initial_end_edge, mappingTable = self.build_dzn_data( src_access_node_id, dst_access_node_id, osdf_config) #mzn_model = "/home/root1/Videos/projects/osdf/test/functest/simulators/osdf/optimizers/routeopt/route_opt.mzn" mzn_model = os.path.join(BASE_DIR, 'route_opt.mzn') routeSolutions = self.get_links(mzn_model, dzn_data, initial_start_edge, initial_end_edge, mappingTable) return { "requestId": request["requestInfo"]["requestId"], "transactionId": request["requestInfo"]["transactionId"], "statusMessage": " ", "requestStatus": "accepted", "solutions": routeSolutions } except Exception as err: audit_log.info(err) raise err
def do_nxi_terminaton(): request_json = request.get_json() req_id = request_json['requestInfo']['requestId'] g.request_id = req_id audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) NxiTerminationApi(request_json).validate() return process_nxi_termination_opt(request_json,osdf_config)
def do_mdons_route_calc(): """ Perform the inter domain route calculation """ request_json = request.get_json() audit_log.info("Inter Domain Calculation Route request received!") response = InterDomainRouteOpt().get_route(request_json, osdf_config) return response
def do_route_calc(): """ Perform the basic route calculations and returnn the vpn-bindings """ request_json = request.get_json() audit_log.info("Calculate Route request received!") response = RouteOpt().get_route(request_json, osdf_config) return response
def create_map_table(self, logical_links): result = map(self.addition, logical_links) parseTemplate = {} for eachItem in result: parseTemplate[eachItem[1]] = eachItem[0] audit_log.info("mapping table") audit_log.info(parseTemplate) return parseTemplate
def do_nst_selection(): request_json = request.get_json() req_id = request_json['requestInfo']['requestId'] audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) NSTSelectionAPI(request_json).validate() audit_log.info(MH.new_worker_thread(req_id, "[for NST selection]")) nst_selection = NstSelection(osdf_config, request_json) nst_selection.start() return req_accept(request_id=req_id, transaction_id=request_json['requestInfo']['transactionId'], request_status="accepted", status_message="")
def log_response_data(response): status_value = '' try: status_value = map_status_value(response) log_message(response.get_data(as_text=True), status_value, 'EXIT') except Exception: try: set_default_audit_mdc(request, status_value, 'EXIT') audit_log.info(response.get_data(as_text=True)) except Exception: set_error_details(300, 'Internal Error') error_log.error("Error logging the response data due to {}".format(traceback.format_exc()))
def do_nssi_selection(): request_json = request.get_json() req_id = request_json['requestInfo']['requestId'] g.request_id = req_id audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) NSSISelectionAPI(request_json).validate() audit_log.info(MH.new_worker_thread(req_id, "[for NSSI selection]")) slice_opt = SliceSelectionOptimizer(osdf_config, slice_config, request_json, 'NSSI') slice_opt.start() return req_accept(request_id=req_id, transaction_id=request_json['requestInfo']['transactionId'], request_status="accepted", status_message="")
def get_links(self, mzn_model, dzn_data, initial_start_edge, initial_end_edge, mappingTable): routes = self.solve(mzn_model, dzn_data) audit_log.info("mocked minizinc solution====>") audit_log.info(routes) converted_links = self.get_links_name(routes, initial_start_edge, initial_end_edge, mappingTable) audit_log.info("converted links===>") audit_log.info(converted_links) return converted_links
def get_links_name(self, routes, initial_start_edge, initial_end_edge, mappingTable): routes = list(routes) try: arr = routes[0]['x'] except Exception as err: audit_log.info("No satisfiable solutions found") raise err listOfLinks = [] for i in range(0, len(routes[0]['x'])): individual_link = {} if arr[i] == 1: # listOfLinks.append(self.fetchLogicalLinks(initial_start_edge[i], initial_end_edge[i], mappingTable)) individual_link["link"] = mappingTable[initial_start_edge[i] + ":" + initial_end_edge[i]] individual_link["start_node"] = initial_start_edge[i] individual_link["end_node"] = initial_end_edge[i] listOfLinks.append(individual_link) return listOfLinks
def get_route(self, request, osdf_config): """ This method processes the mdons route request and returns an optimised path for the given two ports """ try: route_info = request["routeInfo"]["routeRequest"] src_controller_id = route_info["srcDetails"]["controllerId"] src_port_id = route_info["srcDetails"]["interfaceId"] dst_controller_id = route_info["dstDetails"]["controllerId"] dst_port_id = route_info["dstDetails"]["interfaceId"] service_rate = route_info["serviceRate"] dzn_data, mapping_table = self.build_dzn_data(osdf_config, src_controller_id, dst_controller_id, service_rate) audit_log.info("Dzn data") audit_log.info(dzn_data) mzn_model = os.path.join(BASE_DIR, 'route_opt.mzn') links_list = self.find_suitable_path(mzn_model, dzn_data, mapping_table) ordered_list = self.get_ordered_route_list(links_list, src_controller_id, dst_controller_id) solution = self.get_solution_object(ordered_list, src_port_id, dst_port_id) return { "requestId": request["requestInfo"]["requestId"], "transactionId": request["requestInfo"]["transactionId"], "statusMessage": "SUCCESS", "requestStatus": "accepted", "solutions": solution } except Exception as err: audit_log.info(err) raise err
def placement_rest_api(): """Perform placement optimization after validating the request and fetching policies Make a call to the call-back URL with the output of the placement request. Note: Call to Conductor for placement optimization may have redirects, so account for them """ request_json = request.get_json() req_id = request_json['requestInfo']['requestId'] g.request_id = req_id audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) api_version_info = api_data_utils.retrieve_version_info(request, req_id) PlacementAPI(request_json).validate() policies = get_policies(request_json, "placement") audit_log.info(MH.new_worker_thread(req_id, "[for placement]")) t = Thread(target=process_placement_opt, args=(request_json, policies, osdf_config)) t.start() audit_log.info(MH.accepted_valid_request(req_id, request)) return req_accept(request_id=req_id, transaction_id=request_json['requestInfo']['transactionId'], version_info=api_version_info, request_status="accepted", status_message="")
def find_suitable_path(self, mzn_model, dzn_data, mapping_table): """ :param mzn_model: minizinc model details :param dzn_data: minizinc data :param mapping_table: list that maintains AAI link details :return: list of link from after running minizinc """ minizinc_solution = self.solve(mzn_model, dzn_data) audit_log.info("Minizinc Solution ==========>") routes = list(minizinc_solution) audit_log.info(routes) try: arr = routes[0]['x'] except Exception as err: audit_log.info("No minizinc solutions found") raise err links_list = [] for i in range(0, len(routes[0]['x'])): if arr[i] == 1: links_list.append(mapping_table[i]) return links_list
def do_health_check(): """Simple health check""" audit_log.info("A OptimEngine health check v1 request is processed!") return "OK"
def do_osdf_load_policies(): audit_log.info("Uploading policy models") """Upload policy models""" response = upload_policy_models() audit_log.info(response) return "OK"
def do_osdf_health_check(): """Simple health check""" audit_log.info("A health check request is processed!") return "OK"
def build_dzn_data(self, src_access_node_id, dst_access_node_id, osdf_config): Edge_Start = [] Edge_End = [] logical_links = self.get_logical_links(osdf_config) logical_links = logical_links['logical-link'] audit_log.info( "mocked response of AAI received (logical links) successful===>") audit_log.info(logical_links) # prepare map table mappingTable = self.create_map_table(logical_links) audit_log.info("mapping table created successfully====>") audit_log.info(mappingTable) # take the logical link where both the p-interface in same onap if logical_links is not None: audit_log.info('logical links not empty=====>') for logical_link in logical_links: audit_log.info('logical_link') audit_log.info(logical_link) if 'relationship-list' in logical_link.keys(): if not self.is_cross_onap_link(logical_link): # link is in local ONAP audit_log.info('link is inside onap===>') relationship = logical_link["relationship-list"][ "relationship"] relationshipStartNode = relationship[0] audit_log.info('relationshipStartNode') audit_log.info(relationshipStartNode) relationshipStartNodeID = relationshipStartNode[ "related-link"].split("/")[-4] audit_log.info('relationshipStartNodeID') audit_log.info(relationshipStartNodeID) Edge_Start.append(relationshipStartNodeID) relationshipEndtNode = relationship[1] relationshipEndNodeID = relationshipEndtNode[ "related-link"].split("/")[-4] audit_log.info('relationshipEndNodeID') audit_log.info(relationshipEndNodeID) Edge_End.append(relationshipEndNodeID) else: continue audit_log.info("edge start and end array of i/p address are===>") audit_log.info(Edge_Start) audit_log.info(Edge_End) # labeling ip to number for mapping le = preprocessing.LabelEncoder() le.fit(Edge_Start + Edge_End) dzn_start_edge = le.transform(Edge_Start) final_dzn_start_arr = [] for i in range(0, len(dzn_start_edge)): final_dzn_start_arr.append(dzn_start_edge[i]) final_dzn_end_arr = [] dzn_end_edge = le.transform(Edge_End) for j in range(0, len(dzn_end_edge)): final_dzn_end_arr.append(dzn_end_edge[j]) audit_log.info("start and end array that passed in dzn_data===>") audit_log.info(final_dzn_start_arr) audit_log.info(final_dzn_end_arr) link_cost = [] for k in range(0, len(final_dzn_start_arr)): link_cost.append(1) audit_log.info("src_access_node_id") audit_log.info(src_access_node_id) source = le.transform([src_access_node_id]) audit_log.info("vallue of source===>") audit_log.info(source) if source in final_dzn_start_arr: start = source[0] audit_log.info("source node") audit_log.info(start) audit_log.info("dst_access_node_id") audit_log.info(dst_access_node_id) destination = le.transform([dst_access_node_id]) if destination in final_dzn_end_arr: end = destination[0] audit_log.info("destination node") audit_log.info(end) # data to be prepared in the below format: dzn_data = { 'N': self.total_node(final_dzn_start_arr + final_dzn_end_arr), 'M': len(final_dzn_start_arr), 'Edge_Start': final_dzn_start_arr, 'Edge_End': final_dzn_end_arr, 'L': link_cost, 'Start': start, 'End': end, } # can not do reverse mapping outside of this scope, so doing here audit_log.info("reverse mapping after prepared dzn_data") initial_start_edge = le.inverse_transform(final_dzn_start_arr) initial_end_edge = le.inverse_transform(final_dzn_end_arr) audit_log.info(initial_start_edge) audit_log.info(initial_end_edge) return dzn_data, initial_start_edge, initial_end_edge, mappingTable
def do_pci_optimization(): request_json = request.get_json() audit_log.info('request json obtained==>') audit_log.info(request_json) req_id = request_json['requestInfo']['requestId'] audit_log.info('requestID obtained==>') audit_log.info(req_id) g.request_id = req_id audit_log.info(MH.received_request(request.url, request.remote_addr, json.dumps(request_json))) PCIOptimizationAPI(request_json).validate() # disable policy retrieval # policies = get_policies(request_json, "pciopt") audit_log.info(MH.new_worker_thread(req_id, "[for pciopt]")) t = Thread(target=process_pci_optimation, args=(request_json, osdf_config, None)) t.start() audit_log.info(MH.accepted_valid_request(req_id, request)) audit_log.info('reached upto return') return req_accept(request_id=req_id, transaction_id=request_json['requestInfo']['transactionId'], request_status="accepted", status_message="")
def log_message(message, status_value, p_marker='INVOKE'): MDC.put('statusCode', status_value) MDC.put('customField1', p_marker) MDC.put('timer', int((time.process_time() - g.request_start) * 1000)) audit_log.info(message)