1 # -------------------------------------------------------------------------
2 # Copyright (C) 2020 Wipro Limited.
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 # -------------------------------------------------------------------------
20 Module for processing slice selection request
23 from requests import RequestException
24 from threading import Thread
27 from apps.slice_selection.optimizers.conductor.response_processor import ResponseProcessor
28 from osdf.adapters.conductor import conductor
29 from osdf.adapters.policy.interface import get_policies
30 from osdf.logging.osdf_logging import debug_log
31 from osdf.logging.osdf_logging import error_log
32 from osdf.utils.interfaces import get_rest_client
33 from osdf.utils.mdc_utils import mdc_from_json
36 class SliceSelectionOptimizer(Thread):
37 def __init__(self, osdf_config, slice_config, request_json, model_type):
39 self.osdf_config = osdf_config
40 self.slice_config = slice_config
41 self.request_json = request_json
42 self.model_type = model_type
43 self.response_processor = ResponseProcessor(request_json['requestInfo'], slice_config)
46 self.process_slice_selection_opt()
48 def process_slice_selection_opt(self):
49 """Process the slice selection request from the API layer"""
50 req_info = self.request_json['requestInfo']
51 rc = get_rest_client(self.request_json, service='so')
54 if self.model_type == 'NSSI' \
55 and self.request_json['sliceProfile'].get('resourceSharingLevel', "") == 'not-shared':
56 final_response = self.response_processor.get_slice_selection_response([])
59 final_response = self.do_slice_selection()
61 except Exception as ex:
62 error_log.error("Error for {} {}".format(req_info.get('requestId'),
63 traceback.format_exc()))
64 error_message = str(ex)
65 final_response = self.response_processor.process_error_response(error_message)
68 rc.request(json=final_response, noresponse=True)
69 except RequestException:
70 error_log.error("Error sending asynchronous notification for {} {}".format(req_info['request_id'],
71 traceback.format_exc()))
73 def do_slice_selection(self):
74 req_info = self.request_json['requestInfo']
75 app_info = self.slice_config['app_info'][self.model_type]
76 mdc_from_json(self.request_json)
77 requirements = self.request_json.get(app_info['requirements_field'], {})
78 model_info = self.request_json.get(app_info['model_info'])
79 model_name = model_info['name']
80 policies = self.get_app_policies(model_name, app_info['app_name'])
81 request_parameters = self.get_request_parameters(requirements)
85 "resourceModuleName": model_name,
86 "resourceModelInfo": {}
92 'location_enabled': False,
93 'version': '2020-08-13'
95 resp = conductor.request(req_info, demands, request_parameters, {}, template_fields,
96 self.osdf_config, policies)
97 except RequestException as e:
98 resp = e.response.json()
99 error = resp['plans'][0]['message']
100 error_log.error('Error from conductor {}'.format(error))
101 return self.response_processor.process_error_response(error)
103 debug_log.debug("Response from conductor {}".format(str(resp)))
104 recommendations = resp["plans"][0].get("recommendations")
105 subnets = [subnet['domainType'] for subnet in self.request_json['subnetCapabilities']] \
106 if self.request_json.get('subnetCapabilities') else []
107 return self.response_processor.process_response(recommendations, model_info, subnets)
109 def get_request_parameters(self, requirements):
110 camel_to_snake = self.slice_config['attribute_mapping']['camel_to_snake']
111 request_params = {camel_to_snake[key]: value for key, value in requirements.items()}
112 subnet_capabilities = self.request_json.get('subnetCapabilities')
113 if subnet_capabilities:
114 for subnet_capability in subnet_capabilities:
115 domain_type = f"{subnet_capability['domainType'].lower().replace('-', '_')}_"
116 capability_details = subnet_capability['capabilityDetails']
117 for key, value in capability_details.items():
118 request_params[f"{domain_type}{camel_to_snake[key]}"] = value
119 return request_params
121 def get_app_policies(self, model_name, app_name):
122 policy_request_json = self.request_json.copy()
123 policy_request_json['serviceInfo'] = {'serviceName': model_name}
124 if 'preferReuse' in self.request_json:
125 policy_request_json['preferReuse'] = "reuse" if self.request_json['preferReuse'] else "create_new"
126 return get_policies(policy_request_json, app_name)