def get_cell_list(self, network_id):
cell_list_url = '{}/{}'.format(self.config['cpsUrl'],
self.config['cpsCellListUrl'])
data = {'inputParameters': {'regionId': network_id}}
response = self.rc.request(url=cell_list_url, data=json.dumps(data))
debug_log.debug("cell list response {}".format(response))
return sorted([x['idNRCellCU'] for x in response.get('NRCellCU')])
def get_resource_count(query_template, inputs, osdf_config):
query = Template(query_template).render(inputs)
dsl_response = execute_dsl_query(query, "count", osdf_config)
debug_log.debug("dsl_response {}".format(dsl_response))
# the dsl query with format "count" includes the original service-instance, hence reducing one from the result
count = dsl_response["results"][0]
return count.get("service-instance", 0) - 1
def initial_request_to_conductor(rc, conductor_url, conductor_req_json):
"""First steps in the request-redirect chain in making a call to Conductor
:param rc: REST client object for calling conductor
:param conductor_url: conductor's base URL to submit a placement request
:param conductor_req_json: request json object to send to Conductor
:return: URL to check for follow up (similar to redirects);
we keep checking these till we get a result/error
"""
debug_log.debug("Payload to Conductor: {}".format(json.dumps(conductor_req_json)))
raw_resp = rc.request(url=conductor_url, raw_response=True, method="POST",
json=conductor_req_json)
resp = raw_resp.json()
if resp["status"] != "template":
raise RequestException(response=raw_resp, request=raw_resp.request)
time.sleep(10) # 10 seconds wait time to avoid being too quick!
plan_url = resp["links"][0][0]["href"]
debug_log.debug("Attempting to read the plan from "
"the conductor provided url {}".format(plan_url))
raw_resp = rc.request(raw_response=True,
url=plan_url)
resp = raw_resp.json()
if resp["plans"][0]["status"] in ["error"]:
raise RequestException(response=raw_resp, request=raw_resp.request)
return resp, raw_resp # now the caller of this will handle further follow-ups
def execute_dsl_query(query, format, osdf_config):
"""Get the response from AAI
:param query: dsl query to be executed
:param format format of the output
:param osdf_config: configuration specific to OSDF app
:return:response body from AAI
"""
config = osdf_config.deployment
dsl_url = config["aaiUrl"] + config["dslQueryPath"] + format
data = json.dumps({'dsl': query})
debug_log.debug("aai dsl request: {}".format(data))
try:
response = requests.put(dsl_url,
data=data,
headers=AAI_HEADERS,
auth=AUTH,
verify=False)
debug_log.debug("aai dsl response: {}".format(response))
except RequestException as ex:
raise AAIException("Request exception was encountered {}".format(ex))
if response.status_code == 200:
return response.json()
else:
raise AAIException(
"Response code other than 200 from AAI: {} {}".format(
response.status_code, response.content))
def get_model_data(model_id):
with app.app_context():
try:
debug_log.debug(
"getting model data given model_id = {}".format(model_id))
d = dict()
connection = get_db()
cursor = connection.cursor(buffered=True)
query = "SELECT model_id, model_content, description, " \
"solver_type FROM optim_model_data WHERE model_id = %s"
values = (model_id, )
cursor.execute(query, values)
if cursor is None:
return 400, "FAILED"
else:
rows = cursor.fetchone()
if rows is not None:
index = 0
for row in rows:
d[index] = row
index = index + 1
return 200, d
else:
close_db()
return 500, "NOT_FOUND"
except Exception:
error_log.error("error for request_id: {} - {}".format(
model_id, traceback.format_exc()))
close_db()
return 500, "FAILED"
def get_local_policies(local_policy_folder,
local_policy_list,
policy_id_list=None):
"""
Get policies from a local file system.
Required for the following scenarios:
(a) doing work-arounds (e.g. if we are asked to drop some policies for testing purposes)
(b) work-arounds when policy platform is giving issues (e.g. if dev/IST policies are wiped out in an upgrade)
:param local_policy_folder: where the policy files are present
:param local_policy_list: list of local policies
:param policy_id_list: list of policies to get (if unspecified or None, get all)
:return: get policies
"""
debug_log.debug(
"Policy folder: {}, local_list {}, policy id list {}".format(
local_policy_folder, local_policy_list, policy_id_list))
policies = []
if policy_id_list:
for policy_id in policy_id_list:
with open(os.path.join(local_policy_folder,
policy_id + ".json")) as fid:
policies.append(json.load(fid))
else:
for fname in local_policy_list:
with open(os.path.join(local_policy_folder, fname)) as fid:
policies.append(json.load(fid))
return policies
def get_aai_data(request_json, osdf_config):
"""Get the response from AAI
:param request_json: requestjson
:param osdf_config: configuration specific to OSDF app
:return:response body from AAI
"""
nxi_id = request_json["NxIId"]
config = osdf_config.deployment
aai_url = config["aaiUrl"]
aai_req_url = aai_url + config[
"aaiServiceInstanceUrl"] + nxi_id + "?depth=2"
try:
debug_log.debug("aai request: {}".format(aai_req_url))
response = requests.get(aai_req_url,
headers=AAI_HEADERS,
auth=AUTH,
verify=False)
debug_log.debug("aai response: {}".format(response.json()))
except RequestException as e:
raise AAIException("Request exception was encountered {}".format(e))
if response.status_code == 200:
return response.json()
else:
raise AAIException(
"Error response recieved from AAI for the request {}".format(
aai_req_url))
def get_app_policies(self, model_name, app_name):
policy_request_json = self.request_json.copy()
policy_request_json['serviceInfo'] = {'serviceName': model_name}
debug_log.debug("policy_request_json {}".format(
str(policy_request_json)))
return get_policies(policy_request_json,
app_name) # app_name: nst_selection
def delete_file_folder(p):
if not p:
return
debug_log.debug('Deleting folder/file {}'.format(p))
if os.path.isfile(p):
os.remove(p)
else:
rmtree(p, ignore_errors=True)
def update_config(self, data):
new_config = json.loads(data['Value'].decode('utf-8'))
osdf_deployment = new_config['osdf_config']
osdf_core = new_config['common_config']
self.config['osdf_config'].update(osdf_deployment)
self.config['common_config'].update(osdf_core)
debug_log.debug("updated config {}".format(new_config))
debug_log.debug("value changed")
def request(self,
url=None,
method=None,
asjson=True,
ok_codes=(2, ),
raw_response=False,
noresponse=False,
timeout=None,
**kwargs):
"""Sends http request to the specified url
:param url: REST end point to query
:param method: GET or POST (default is None => self.method)
:param asjson: whether the expected response is in json format
:param ok_codes: expected codes (prefix matching -- e.g. can be (20, 21, 32) or (2, 3))
:param noresponse: If no response is expected (as long as response codes are OK)
:param raw_response: If we need just the raw response (e.g. conductor sends transaction IDs in headers)
:param timeout: Connection and read timeouts
:param kwargs: Other parameters
:return:
"""
if not self.req_id:
debug_log.debug("Requesting URL: {}".format(url or self.url))
else:
debug_log.debug("Requesting URL: {} for request ID: {}".format(
url or self.url, self.req_id))
if not url:
url = self.url
if not self.verify and url.startswith("https"):
verify = osdf_config.deployment["aaf_ca_certs"]
else:
verify = self.verify
res = requests.request(url=url or self.url,
method=method or self.method,
auth=self.auth,
headers=self.headers,
timeout=timeout or self.timeout,
verify=verify,
**kwargs)
if self.log_func:
self.log_func(MH.received_http_response(res))
res_code = str(res.status_code)
if not any(res_code.startswith(x) for x in map(str, ok_codes)):
raise BaseException(res.raise_for_status())
if raw_response:
return res
elif noresponse:
return None
elif asjson:
return res.json()
else:
return res.content
def get_app_policies(self, model_name, app_name):
policy_request_json = self.request_json.copy()
policy_request_json['serviceInfo'] = {'serviceName': model_name}
if 'serviceProfile' in self.request_json:
slice_scope = self.request_json['serviceProfile']['resourceSharingLevel']
if 'preferReuse' in self.request_json and slice_scope == "shared":
slice_scope = slice_scope + "," + ("reuse" if self.request_json['preferReuse'] else "create_new")
policy_request_json['slice_scope'] = slice_scope
debug_log.debug("policy_request_json {}".format(str(policy_request_json)))
return get_policies(policy_request_json, app_name)
def get_nbr_list(self, network_id, cell_id):
ts = dt.strftime(dt.now(), '%Y-%m-%d %H:%M:%S%z')
nbr_list_url = '{}/{}/{}/{}'.format(
self.config['configDbUrl'], self.config['configDbGetNbrListUrl'],
cell_id, ts)
response = self.rc.request(url=nbr_list_url, raw_response=True).json()
debug_log.debug("cell_id {} nbr_list {}".format(
cell_id, response.get('nbrList')))
return response.get('nbrList', [])
def watch(self):
index = None
while True:
try:
index, data = yield self.consul.kv.get('osdfconfiguration',
index=index)
if data is not None:
self.update_config(data)
except Timeout:
pass
except Exception as e:
debug_log.debug('Exception Encountered {}'.format(e))
def osdf_response_for_request_accept(
request_id="",
transaction_id="",
request_status="",
status_message="",
version_info={
'placementVersioningEnabled': False,
'placementMajorVersion': '1',
'placementMinorVersion': '0',
'placementPatchVersion': '0'
},
response_code=202,
as_http=True):
"""Helper method to create a response object for request acceptance, so that the object can be sent to a client
:param request_id: request ID provided by the caller
:param transaction_id: transaction ID provided by the caller
:param request_status: the status of a request
:param status_message: details on the status of a request
:param response_code: the HTTP status code to send -- default is 202 (accepted)
:param as_http: whether to send response as HTTP response object or as a string
:return: if as_http is True, return a HTTP Response object. Otherwise, return json-encoded-message
"""
response_message = ACCEPTED_MESSAGE_TEMPLATE.render(
request_id=request_id,
transaction_id=transaction_id,
request_status=request_status,
status_message=status_message)
if not as_http:
return response_message
response = Response(response_message,
content_type='application/json; charset=utf-8')
response.headers.add('content-length', len(response_message))
placement_ver_enabled = version_info['placementVersioningEnabled']
if placement_ver_enabled:
placement_minor_version = version_info['placementMinorVersion']
placement_patch_version = version_info['placementPatchVersion']
placement_major_version = version_info['placementMajorVersion']
x_latest_version = placement_major_version + '.' + placement_minor_version + '.' + placement_patch_version
response.headers.add('X-MinorVersion', placement_minor_version)
response.headers.add('X-PatchVersion', placement_patch_version)
response.headers.add('X-LatestVersion', x_latest_version)
debug_log.debug(
"Versions set in HTTP header for synchronous response: X-MinorVersion: {} X-PatchVersion: {} X-LatestVersion: {}"
.format(placement_minor_version, placement_patch_version,
x_latest_version))
response.status_code = response_code
return response
def get_aaf_permissions(uid, passwd):
key = base64.b64encode(bytes("{}_{}".format(uid, passwd), "ascii"))
time_delta = timedelta(
minutes=deploy_config.get('aaf_cache_expiry_mins', 5))
perms = perm_cache.get(key)
if perms and datetime.now() < perms.get(EXPIRE_TIME):
debug_log.debug("Returning cached value")
return perms
debug_log.debug("Invoking AAF authentication API")
perms = {
EXPIRE_TIME: datetime.now() + time_delta,
'roles': remote_api(passwd, uid)
}
perm_cache[key] = perms
return perms
def get_options(argv):
program_version_string = '%%prog %s' % "v1.0"
program_longdesc = ""
program_license = ""
parser = OptionParser(version=program_version_string, epilog=program_longdesc, description=program_license)
parser.add_option("-l", "--local", dest="local", help="run locally", action="store_true", default=False)
parser.add_option("-t", "--devtest", dest="devtest", help="run in dev/test environment", action="store_true",
default=False)
parser.add_option("-d", "--debughost", dest="debughost",
help="IP Address of host running debug server", default='')
parser.add_option("-p", "--debugport", dest="debugport",
help="Port number of debug server", type=int, default=5678)
opts, args = parser.parse_args(argv)
if opts.debughost:
debug_log.debug('pydevd.settrace({}, port={})'.format(opts.debughost, opts.debugport))
# pydevd.settrace(opts.debughost, port=opts.debugport)
return opts
def py_solver(py_content, opt_info):
py_file = '/tmp/custom_heuristics_{}.py'.format(
datetime.timestamp(datetime.now()))
with open(py_file, "wt") as f:
f.write(py_content)
if opt_info['optData'].get('json'):
data_content = json.dumps(opt_info['optData']['json'])
input_file = '/tmp/optim_engine_{}.json'.format(
datetime.timestamp(datetime.now()))
elif opt_info['optData'].get('text'):
data_content = opt_info['optData']['text']
input_file = '/tmp/optim_engine_{}.txt'.format(
datetime.timestamp(datetime.now()))
with open(input_file, "wt") as f:
f.write(data_content)
output_file = '/tmp/opteng_output_{}.json'.format(
datetime.timestamp(datetime.now()))
command = ['python', py_file, input_file, output_file]
try:
p = subprocess.run(command,
stderr=subprocess.STDOUT,
stdout=subprocess.PIPE)
debug_log.debug('Process return code {}'.format(p.returncode))
if p.returncode > 0:
error_log.error('Process return code {} {}'.format(
p.returncode, p.stdout))
return 'error', {}
with open(output_file) as file:
data = file.read()
return 'success', json.loads(data)
except Exception as e:
error_log.error("Error running optimizer {}".format(
traceback.format_exc()))
return 'error', {}
finally:
cleanup((input_file, output_file, py_file))
def create_model_data(model_api):
with app.app_context():
try:
model_info = model_api['modelInfo']
model_id = model_info['modelId']
debug_log.debug("persisting model_api {}".format(model_id))
connection = get_db()
cursor = connection.cursor(buffered=True)
query = "SELECT model_id FROM optim_model_data WHERE model_id = %s"
values = (model_id, )
cursor.execute(query, values)
if cursor.fetchone() is None:
query = "INSERT INTO optim_model_data (model_id, model_content, description, solver_type) VALUES " \
"(%s, %s, %s, %s)"
values = (model_id, model_info['modelContent'],
model_info.get('description'), model_info['solver'])
cursor.execute(query, values)
g.pg.commit()
debug_log.debug(
"A record successfully inserted for request_id: {}".format(
model_id))
return retrieve_model_data(model_id)
close_db()
else:
query = "UPDATE optim_model_data SET model_content = %s, description = %s, solver_type = %s where " \
"model_id = %s "
values = (model_info['modelContent'],
model_info.get('description'), model_info['solver'],
model_id)
cursor.execute(query, values)
g.pg.commit()
return retrieve_model_data(model_id)
close_db()
except Exception as err:
error_log.error("error for request_id: {} - {}".format(
model_id, traceback.format_exc()))
close_db()
raise BusinessException(err)
def delete_model_data(model_id):
with app.app_context():
try:
debug_log.debug(
"deleting model data given model_id = {}".format(model_id))
connection = get_db()
cursor = connection.cursor(buffered=True)
query = "delete from optim_model_data WHERE model_id = %s"
values = (model_id, )
cursor.execute(query, values)
g.pg.commit()
close_db()
resp = {
"statusMessage":
"model data for modelId {} deleted".format(model_id)
}
return build_response(json.dumps(resp), 200)
except Exception as err:
error_log.error("error deleting model_id: {} - {}".format(
model_id, traceback.format_exc()))
close_db()
raise BusinessException(err)
def get_nbr_list(self, network_id, cell_id):
nbr_list_url = '{}/{}'.format(self.config['cpsUrl'],
self.config['cpsNbrListUrl'])
data = {
'inputParameters': {
'regionId': network_id,
'idNRCellCU': cell_id
}
}
response = self.rc.request(url=nbr_list_url, data=json.dumps(data))
debug_log.debug("nbr list response {}".format(response))
nbr_list = []
for cell_relation in response.get('NRCellRelation'):
nbr = {
'targetCellId': cell_relation['attributes']['nRTCI'],
'pciValue': int(cell_relation['attributes']['nRPCI']),
'ho': cell_relation['attributes']['isHOAllowed']
}
nbr_list.append(nbr)
debug_log.debug("cell_id {} nbr_list {}".format(cell_id, nbr_list))
return nbr_list
def local_policies_location(req_json, osdf_config, service_type):
"""Get folder and list of policy_files if "local policies" option is enabled
:param service_type: placement supported for now, but can be any other service
:return: a tuple (folder, file_list) or None
"""
lp = osdf_config.core.get('osdf_temp', {}).get('local_policies', {})
if lp.get('global_disabled'):
return None # short-circuit to disable all local policies
if lp.get('local_{}_policies_enabled'.format(service_type)):
debug_log.debug(
'Loading local policies for service type: {}'.format(service_type))
if service_type == "scheduling":
return lp.get('{}_policy_dir'.format(service_type)), lp.get(
'{}_policy_files'.format(service_type))
else:
service_name = req_json['serviceInfo']['serviceName']
debug_log.debug(
'Loading local policies for service name: {}'.format(
service_name))
return lp.get('{}_policy_dir_{}'.format(service_type, service_name.lower())), \
lp.get('{}_policy_files_{}'.format(service_type, service_name.lower()))
return None
def get_all_models():
with app.app_context():
try:
debug_log.debug("getting all model data".format())
connection = get_db()
cursor = connection.cursor(buffered=True)
query = "SELECT model_id, model_content, description, solver_type FROM optim_model_data"
cursor.execute(query)
if cursor is None:
return 400, "FAILED"
else:
rows = cursor.fetchall()
if rows is not None:
return 200, rows
else:
close_db()
return 500, "NOT_FOUND"
except Exception:
error_log.error("error for request_id: {}".format(
traceback.format_exc()))
close_db()
return 500, "FAILED"
def do_slice_selection(self):
req_info = self.request_json['requestInfo']
app_info = self.slice_config['app_info'][self.model_type]
mdc_from_json(self.request_json)
requirements = self.request_json.get(app_info['requirements_field'], {})
model_info = self.request_json.get(app_info['model_info'])
model_name = model_info['name']
policies = self.get_app_policies(model_name, app_info['app_name'])
request_parameters = self.get_request_parameters(requirements, model_info)
demands = [
{
"resourceModuleName": model_name,
"resourceModelInfo": {}
}
]
try:
template_fields = {
'location_enabled': False,
'version': '2020-08-13'
}
resp = conductor.request(req_info, demands, request_parameters, {}, template_fields,
self.osdf_config, policies)
except RequestException as e:
resp = e.response.json()
error = resp['plans'][0]['message']
if isinstance(error, list) and "Unable to find any" in error[0]:
return self.response_processor.get_slice_selection_response([])
error_log.error('Error from conductor {}'.format(error))
return self.response_processor.process_error_response(error)
debug_log.debug("Response from conductor {}".format(str(resp)))
recommendations = resp["plans"][0].get("recommendations")
subnets = [subnet['domainType'] for subnet in self.request_json['subnetCapabilities']] \
if self.request_json.get('subnetCapabilities') else []
return self.response_processor.process_response(recommendations, model_info, subnets, self.model_type)
def get_conductor(self, req_info, request_parameters, policies,
model_name):
demands = [{"resourceModuleName": model_name, "resourceModelInfo": {}}]
try:
template_fields = {
'location_enabled': False,
'version': '2020-08-13'
}
resp = conductor.request(req_info, demands, request_parameters, {},
template_fields, self.osdf_config,
policies)
except RequestException as e:
resp = e.response.json()
error = resp['plans'][0]['message']
if "Unable to find any" in error:
return self.get_nst_selection_response([])
error_log.error('Error from conductor {}'.format(error))
return self.error_response(error)
debug_log.debug(
"Response from conductor in get_conductor method {}".format(
str(resp)))
recommendations = resp["plans"][0].get("recommendations")
return self.process_response(recommendations, model_name)
def retrieve_version_info(request, request_id):
version_info_dict = defaultdict(dict)
config = osdf_config.deployment
placement_ver_enabled = config.get('placementVersioningEnabled', False)
if placement_ver_enabled:
placement_major_version = config.get('placementMajorVersion', None)
placement_minor_version = config.get('placementMinorVersion', None)
placement_patch_version = config.get('placementPatchVersion', None)
http_header = request.headers.environ
http_x_minorversion = http_header.get("HTTP_X_MINORVERSION")
http_x_patchversion = http_header.get("HTTP_X_PATCHVERSION")
http_x_latestversion = http_header.get("HTTP_X_LATESTVERSION")
debug_log.debug("Versions sent in HTTP header for request ID {} are: X-MinorVersion: {} X-PatchVersion: {} X-LatestVersion: {}"
.format(request_id, http_x_minorversion, http_x_patchversion, http_x_latestversion))
debug_log.debug("latest versions specified in osdf config file are: placementMajorVersion: {} placementMinorVersion: {} placementPatchVersion: {}"
.format(placement_major_version, placement_minor_version, placement_patch_version))
else:
placement_major_version = config.get('placementDefaultMajorVersion', "1")
placement_minor_version = config.get('placementDefaultMinorVersion', "0")
placement_patch_version = config.get('placementDefaultPatchVersion', "0")
debug_log.debug("Default versions specified in osdf config file are: placementDefaultMajorVersion: {} placementDefaultMinorVersion: {} placementDefaultPatchVersion: {}"
.format(placement_major_version, placement_minor_version, placement_patch_version))
version_info_dict.update({
'placementVersioningEnabled': placement_ver_enabled,
'placementMajorVersion': str(placement_major_version),
'placementMinorVersion': str(placement_minor_version),
'placementPatchVersion': str( placement_patch_version)
})
return version_info_dict
def conductor_response_processor(conductor_response, req_id, transaction_id):
"""Build a response object to be sent to client's callback URL from Conductor's response
This includes Conductor's placement optimization response, and required ASDC license artifacts
:param conductor_response: JSON response from Conductor
:param raw_response: Raw HTTP response corresponding to above
:param req_id: Id of a request
:return: JSON object that can be sent to the client's callback URL
"""
composite_solutions = []
name_map = {
"physical-location-id": "cloudClli",
"host_id": "vnfHostName",
"cloud_version": "cloudVersion",
"cloud_owner": "cloudOwner",
"cloud": "cloudRegionId",
"service": "serviceInstanceId",
"is_rehome": "isRehome",
"location_id": "locationId",
"location_type": "locationType",
"directives": "oof_directives"
}
for reco in conductor_response['plans'][0]['recommendations']:
for resource in reco.keys():
c = reco[resource]['candidate']
solution = {
'resourceModuleName': resource,
'serviceResourceId':
reco[resource].get('service_resource_id', ""),
'solution': {
"identifierType":
name_map.get(c['inventory_type'], c['inventory_type']),
'identifiers': [c['candidate_id']],
'cloudOwner':
c.get('cloud_owner', "")
},
'assignmentInfo': []
}
for key, value in c.items():
if key in [
"location_id", "location_type", "is_rehome", "host_id"
]:
try:
solution['assignmentInfo'].append({
"key":
name_map.get(key, key),
"value":
value
})
except KeyError:
debug_log.debug(
"The key[{}] is not mapped and will not be returned in assignment info"
.format(key))
for key, value in reco[resource]['attributes'].items():
try:
solution['assignmentInfo'].append({
"key":
name_map.get(key, key),
"value":
value
})
except KeyError:
debug_log.debug(
"The key[{}] is not mapped and will not be returned in assignment info"
.format(key))
composite_solutions.append(solution)
request_status = "completed" if conductor_response['plans'][0]['status'] == "done" \
else conductor_response['plans'][0]['status']
status_message = conductor_response.get('plans')[0].get('message', "")
solution_info = {}
if composite_solutions:
solution_info.setdefault('placementSolutions', [])
solution_info['placementSolutions'].append(composite_solutions)
resp = {
"transactionId": transaction_id,
"requestId": req_id,
"requestStatus": request_status,
"statusMessage": status_message,
"solutions": solution_info
}
return resp
def request(req_info, demands, request_parameters, service_info, template_fields,
osdf_config, flat_policies):
config = osdf_config.deployment
local_config = osdf_config.core
uid, passwd = config['conductorUsername'], config['conductorPassword']
conductor_url = config['conductorUrl']
req_id = req_info["requestId"]
transaction_id = req_info['transactionId']
headers = dict(transaction_id=transaction_id)
placement_ver_enabled = config.get('placementVersioningEnabled', False)
if placement_ver_enabled:
cond_minor_version = config.get('conductorMinorVersion', None)
if cond_minor_version is not None:
x_minor_version = str(cond_minor_version)
headers.update({'X-MinorVersion': x_minor_version})
debug_log.debug("Versions set in HTTP header to "
"conductor: X-MinorVersion: {} ".format(x_minor_version))
max_retries = config.get('conductorMaxRetries', 30)
ping_wait_time = config.get('conductorPingWaitTime', 60)
rc = RestClient(userid=uid, passwd=passwd, method="GET", log_func=debug_log.debug,
headers=headers)
conductor_req_json_str = conductor_api_builder(req_info, demands, request_parameters,
service_info, template_fields, flat_policies,
local_config)
conductor_req_json = json.loads(conductor_req_json_str)
debug_log.debug("Sending first Conductor request for request_id {}".format(req_id))
resp, raw_resp = initial_request_to_conductor(rc, conductor_url, conductor_req_json)
# Very crude way of keeping track of time.
# We are not counting initial request time, first call back, or time for HTTP request
total_time, ctr = 0, 2
client_timeout = req_info['timeout']
configured_timeout = max_retries * ping_wait_time
max_timeout = min(client_timeout, configured_timeout)
while True: # keep requesting conductor till we get a result or we run out of time
if resp is not None:
if resp["plans"][0].get("status") in ["error"]:
raise RequestException(response=raw_resp, request=raw_resp.request)
if resp["plans"][0].get("status") in ["done", "not found", "solved"]:
return resp
new_url = resp['plans'][0]['links'][0][0]['href'] # TODO(krishna): check why a list of lists
if total_time >= max_timeout:
raise BusinessException("Conductor could not provide a solution within {} seconds,"
"this transaction is timing out".format(max_timeout))
time.sleep(ping_wait_time)
ctr += 1
debug_log.debug("Attempt number {} url {}; prior status={}"
.format(ctr, new_url, resp['plans'][0]['status']))
total_time += ping_wait_time
try:
raw_resp = rc.request(new_url, raw_response=True)
resp = raw_resp.json()
except RequestException as e:
debug_log.debug("Conductor attempt {} for request_id {} has failed because {}"
.format(ctr, req_id, str(e)))
def process_nxi_termination_opt(request_json, osdf_config):
"""Process the nxi Termination request from API layer
:param request_json: api request
:param osdf_config: configuration specific to OSDF app
:return: response as a success,failure
"""
request_type = request_json["type"]
request_info = request_json.get("requestInfo", {})
addtnl_args = request_info.get("addtnlArgs", {})
query_templates = osdf_config.core["nxi_termination"]["query_templates"]
inputs = {"instance_id": request_json["NxIId"]}
try:
if request_type == "NSSI":
templates = query_templates["nssi"]
for template in templates:
resource_count = get_resource_count(template, inputs,
osdf_config)
if resource_count == -1:
continue
elif resource_count > 1 or (
resource_count == 1
and not addtnl_args.get("serviceInstanceId")):
terminate_response = False
elif resource_count == 0:
terminate_response = True
elif resource_count == 1 and addtnl_args.get(
"serviceInstanceId"):
new_template = template + "('service-instance-id','{}')".format(
addtnl_args["serviceInstanceId"])
terminate_response = get_resource_count(
new_template, inputs, osdf_config) == 1
return set_response("success", "", request_info,
terminate_response)
if request_type == "NSI":
allotted_resources = get_allotted_resources(
request_json, osdf_config)
resource_count = len(allotted_resources)
if resource_count == 1 and addtnl_args.get("serviceInstanceId"):
debug_log.debug("resource count {}".format(resource_count))
terminate_response = False
properties = allotted_resources[0]["relationship-data"]
for property in properties:
if property["relationship-key"] == "service-instance.service-instance-id" \
and property["relationship-value"] == addtnl_args.get("serviceInstanceId"):
terminate_response = True
elif resource_count > 1 or (
resource_count == 1
and not addtnl_args.get("serviceInstanceId")):
terminate_response = False
elif resource_count == 0:
terminate_response = True
return set_response("success", "", request_info, terminate_response)
except AAIException as e:
reason = str(e)
return set_response("failure", reason, request_info)
except Exception as e:
reason = "{} Exception Occurred while processing".format(str(e))
return set_response("failure", reason, request_info)
