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)
