1 # -------------------------------------------------------------------------
2 # Copyright (c) 2020 Huawei Intellectual Property
4 # Licensed under the Apache License, Version 2.0 (the "License");
5 # you may not use this file except in compliance with the License.
6 # You may obtain a copy of the License at
8 # http://www.apache.org/licenses/LICENSE-2.0
10 # Unless required by applicable law or agreed to in writing, software
11 # distributed under the License is distributed on an "AS IS" BASIS,
12 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 # See the License for the specific language governing permissions and
14 # limitations under the License.
16 # -------------------------------------------------------------------------
21 from requests.auth import HTTPBasicAuth
23 from osdf.utils.mdc_utils import mdc_from_json
24 from osdf.logging.osdf_logging import MH, audit_log, error_log, debug_log
26 from sklearn import preprocessing
29 BASE_DIR = os.path.dirname(__file__)
34 This values will need to deleted..
35 only added for the debug purpose
37 # DNS server and standard port of AAI..
38 # TODO: read the port from the configuration and add to DNS
40 "X-TransactionId": "9999",
42 "Accept": "application/json",
43 "Content-Type": "application/json",
46 def is_cross_onap_link(self, logical_link):
48 This method checks if cross link is cross onap
52 for relationship in logical_link["relationship-list"]["relationship"]:
53 if relationship["related-to"] == "ext-aai-network":
57 def get_links_name(self, routes,initial_start_edge,initial_end_edge, mappingTable):
61 except Exception as err:
62 audit_log.info("No satisfiable solutions found")
65 for i in range(0, len(routes[0]['x'])):
68 # listOfLinks.append(self.fetchLogicalLinks(initial_start_edge[i], initial_end_edge[i], mappingTable))
69 individual_link["link"] = mappingTable[initial_start_edge[i] + ":" + initial_end_edge[i]]
70 individual_link["start_node"] = initial_start_edge[i]
71 individual_link["end_node"] = initial_end_edge[i]
72 listOfLinks.append(individual_link)
76 def solve(self, mzn_model, dzn_data):
77 return pymzn.minizinc(mzn=mzn_model, data=dzn_data)
79 def get_links(self, mzn_model, dzn_data, initial_start_edge,initial_end_edge, mappingTable):
80 routes = self.solve(mzn_model, dzn_data)
81 audit_log.info("mocked minizinc solution====>")
82 audit_log.info(routes)
84 converted_links=self.get_links_name(routes, initial_start_edge,initial_end_edge, mappingTable)
85 audit_log.info("converted links===>")
86 audit_log.info(converted_links)
87 return converted_links
89 def addition(self, data):
91 if 'relationship-list' in data.keys():
92 relationship = data["relationship-list"]["relationship"]
93 for index, eachItem in enumerate(relationship):
94 temp = eachItem["relationship-data"][0]
95 if index == len(relationship) - 1:
96 res += temp['relationship-value']
98 res += temp['relationship-value'] + ":"
100 return data["link-name"], res
102 return data["link-name"], res
104 def create_map_table(self, logical_links):
105 result = map(self.addition, logical_links)
109 for eachItem in result:
110 parseTemplate[eachItem[1]] = eachItem[0]
111 audit_log.info("mapping table")
112 audit_log.info(parseTemplate)
115 def build_dzn_data(self, src_access_node_id, dst_access_node_id, osdf_config):
118 logical_links = self.get_logical_links(osdf_config)
121 logical_links = logical_links['logical-link']
122 audit_log.info("mocked response of AAI received (logical links) successful===>")
123 audit_log.info(logical_links)
125 mappingTable = self.create_map_table(logical_links)
126 audit_log.info("mapping table created successfully====>")
127 audit_log.info(mappingTable)
128 # take the logical link where both the p-interface in same onap
129 if logical_links is not None:
130 audit_log.info('logical links not empty=====>')
131 for logical_link in logical_links:
132 audit_log.info('logical_link')
133 audit_log.info(logical_link)
135 if 'relationship-list' in logical_link.keys():
136 if not self.is_cross_onap_link(logical_link):
137 # link is in local ONAP
138 audit_log.info('link is inside onap===>')
139 relationship = logical_link["relationship-list"]["relationship"]
141 relationshipStartNode = relationship[0]
142 audit_log.info('relationshipStartNode')
143 audit_log.info(relationshipStartNode)
144 relationshipStartNodeID = relationshipStartNode["related-link"].split("/")[-4]
145 audit_log.info('relationshipStartNodeID')
146 audit_log.info(relationshipStartNodeID)
147 Edge_Start.append(relationshipStartNodeID)
149 relationshipEndtNode = relationship[1]
150 relationshipEndNodeID = relationshipEndtNode["related-link"].split("/")[-4]
151 audit_log.info('relationshipEndNodeID')
152 audit_log.info(relationshipEndNodeID)
153 Edge_End.append(relationshipEndNodeID)
157 audit_log.info("edge start and end array of i/p address are===>")
158 audit_log.info(Edge_Start)
159 audit_log.info(Edge_End)
160 # labeling ip to number for mapping
161 le = preprocessing.LabelEncoder()
162 le.fit(Edge_Start + Edge_End)
163 dzn_start_edge = le.transform(Edge_Start)
165 final_dzn_start_arr = []
166 for i in range(0, len(dzn_start_edge)):
167 final_dzn_start_arr.append(dzn_start_edge[i])
169 final_dzn_end_arr = []
170 dzn_end_edge = le.transform(Edge_End)
171 for j in range(0, len(dzn_end_edge)):
172 final_dzn_end_arr.append(dzn_end_edge[j])
174 audit_log.info("start and end array that passed in dzn_data===>")
175 audit_log.info(final_dzn_start_arr)
176 audit_log.info(final_dzn_end_arr)
179 for k in range(0, len(final_dzn_start_arr)):
182 audit_log.info("src_access_node_id")
183 audit_log.info(src_access_node_id)
184 source= le.transform([src_access_node_id])
185 audit_log.info("vallue of source===>")
186 audit_log.info(source)
187 if source in final_dzn_start_arr :
189 audit_log.info("source node")
190 audit_log.info(start)
192 audit_log.info("dst_access_node_id")
193 audit_log.info(dst_access_node_id)
194 destination= le.transform([dst_access_node_id])
195 if destination in final_dzn_end_arr :
197 audit_log.info("destination node")
199 # data to be prepared in the below format:
201 'N': self.total_node(final_dzn_start_arr + final_dzn_end_arr),
202 'M': len(final_dzn_start_arr),
203 'Edge_Start': final_dzn_start_arr,
204 'Edge_End': final_dzn_end_arr,
209 # can not do reverse mapping outside of this scope, so doing here
210 audit_log.info("reverse mapping after prepared dzn_data")
211 initial_start_edge=le.inverse_transform(final_dzn_start_arr)
212 initial_end_edge=le.inverse_transform(final_dzn_end_arr)
213 audit_log.info(initial_start_edge)
214 audit_log.info(initial_end_edge)
215 return dzn_data, initial_start_edge,initial_end_edge, mappingTable
217 def total_node(self, node):
219 for i in range(0, len(node)):
221 total_node = len(nodeSet)
224 def get_route(self, request, osdf_config):
231 routeInfo = request["routeInfo"]["routeRequests"]
232 routeRequest = routeInfo[0]
233 src_access_node_id = routeRequest["srcPort"]["accessNodeId"]
234 dst_access_node_id = routeRequest["dstPort"]["accessNodeId"]
236 dzn_data, initial_start_edge, initial_end_edge, mappingTable = self.build_dzn_data(src_access_node_id, dst_access_node_id, osdf_config)
237 #mzn_model = "/home/root1/Videos/projects/osdf/test/functest/simulators/osdf/optimizers/routeopt/route_opt.mzn"
238 mzn_model = os.path.join(BASE_DIR, 'route_opt.mzn')
240 routeSolutions = self.get_links(mzn_model, dzn_data, initial_start_edge,initial_end_edge, mappingTable)
243 "requestId": request["requestInfo"]["requestId"],
244 "transactionId": request["requestInfo"]["transactionId"],
245 "statusMessage": " ",
246 "requestStatus": "accepted",
247 "solutions": routeSolutions
249 except Exception as err:
253 def get_logical_links(self, osdf_config):
255 This method returns list of all cross ONAP links
256 from /aai/v14/network/logical-links?operation-status="Up"
257 :return: logical-links[]
260 config = osdf_config.deployment
261 aai_url = config["aaiUrl"]
262 aai_req_url = aai_url + config["aaiGetLinksUrl"]
264 response = requests.get(aai_req_url,headers=self.aai_headers,auth=HTTPBasicAuth("AAI", "AAI"),verify=False)
265 if response.status_code == 200:
266 return response.json()