def get_csar(self, csar_id):
package_info = {}
csar_in_catalog = query_csar_from_catalog(csar_id)
props_of_catalog = [
"name", "provider", "version", "operationalState", "usageState",
"onBoardState", "processState", "deletionPending", "downloadUri",
"createTime", "modifyTime", "format", "size"
]
for prop in props_of_catalog:
package_info[prop] = ignore_case_get(csar_in_catalog, prop)
csars = NSDModel.objects.filter(id=csar_id)
if csars:
package_info["nsdId"] = csars[0].nsd_id
package_info["nsdProvider"] = csars[0].vendor
package_info["nsdVersion"] = csars[0].version
nss = NSInstModel.objects.filter(nspackage_id=csar_id)
ns_instance_info = [{
"nsInstanceId": ns.id,
"nsInstanceName": ns.name
} for ns in nss]
return [
0, {
"csarId": csar_id,
"packageInfo": package_info,
"nsInstanceInfo": ns_instance_info
}
]
def select_vnfm(vnfm_type, vim_id):
uri = "/external-system/esr-vnfm-list"
ret = call_aai(uri, "GET")
if ret[0] > 0:
logger.error("Failed to call %s: %s", uri, ret[1])
raise NSLCMException('Failed to get vnfms from extsys.')
vnfms = json.JSONDecoder().decode(ret[1])
vnfms = ignore_case_get(vnfms, "esr-vnfm")
for vnfm in vnfms:
vnfm_info = get_vnfm_by_id(vnfm.get("vnfm-id"))
vnfmtype = ignore_case_get(vnfm_info, "type")
vimid = ignore_case_get(vnfm_info, "vimId")
if vnfmtype == vnfm_type and vimid == vim_id:
return vnfm_info
raise NSLCMException('No vnfm found with %s in vim(%s)' %
(vnfm_type, vim_id))
def post(self, request):
logger.debug("NfGrant--post::> %s" % request.data)
try:
req_serializer = GrantVnfReqSerializer(data=request.data)
if not req_serializer.is_valid():
raise Exception(req_serializer.errors)
vnf_inst_id = ignore_case_get(request.data, 'vnfInstanceId')
job_id = JobUtil.create_job(JOB_TYPE.VNF, JOB_ACTION.GRANT, vnf_inst_id)
rsp = GrantVnfs(request.data, job_id).send_grant_vnf_to_resMgr()
"""
rsp = {
"vim": {
"vimid": ignore_case_get(ignore_case_get(request.data, 'additionalparam'), 'vimid'),
"accessinfo": {
"tenant": "admin"
}
}
}
"""
# resp_serializer = GrantVnfRespSerializer(data=rsp)
# if not resp_serializer.is_valid():
# raise Exception(resp_serializer.errors)
return Response(data=rsp, status=status.HTTP_201_CREATED)
except Exception as e:
logger.error(e.args[0])
logger.error(traceback.format_exc())
return Response(data={'error': '%s' % e.args[0]}, status=status.HTTP_409_CONFLICT)
def __init__(self, vnfmId, vnfInstanceId, data):
logger.debug(
"[Notify VNF Identifier Creation] vnfmId=%s, vnfInstanceId=%s, data=%s"
% (vnfmId, vnfInstanceId, data))
self.vnfm_id = vnfmId
self.m_vnf_instance_id = vnfInstanceId
self.time_stamp = ignore_case_get(data, 'timeStamp')
def get_and_check_params(self):
nf_info = NfInstModel.objects.filter(nfinstid=self.vnf_instance_id)
if not nf_info:
raise NSLCMException('VNF instance[id=%s] does not exist' % self.vnf_instance_id)
logger.debug('vnfd_model = %s, vnf_instance_id = %s' % (nf_info[0].vnfd_model, self.vnf_instance_id))
self.nf_model = nf_info[0].vnfd_model
self.m_nf_inst_id = nf_info[0].mnfinstid
self.vnfm_inst_id = nf_info[0].vnfm_inst_id
self.nf_additional_params = ignore_case_get(self.data, 'additionalParams')
if not self.nf_additional_params:
raise NSLCMException('additionalParams parameter does not exist or value incorrect')
actionvminfo = ignore_case_get(self.nf_additional_params, 'actionvminfo')
vmid = ignore_case_get(actionvminfo, 'vmid')
self.nf_heal_params = {
"action": "vmReset",
"affectedvm": {
"vmid": vmid,
"vduid": self.get_vudId(vmid),
"vmname": self.get_vmname(vmid)
}
}
retry_count = 10
while (retry_count > 0):
resp = restcall.call_req('http://%s:%s/events' % (MR_IP, MR_PORT),
'',
'',
restcall.rest_no_auth,
'/test/bins/1?timeout=15000',
'GET')
if resp[2] == '200' and resp[1] != '[]':
for message in eval(resp[1]):
if 'powering-off' in message:
action = "vmReset"
vm_info = json.loads(message)
if vmid == vm_info['instance_id']:
vduid = self.get_vudId(vm_info['instance_id'])
self.nf_heal_params = {
"action": action,
"affectedvm": {
"vmid": vm_info['instance_id'],
"vduid": vduid,
"vmname": vm_info['display_name']
}
}
retry_count = -1
retry_count = retry_count - 1
def create_port(vim_cache, res_cache, data, port, do_notify, res_type):
location_info = None
port_ref_vdu_id = ignore_case_get(port, "vdu_id")
for vdu in ignore_case_get(data, "vdus"):
if vdu["vdu_id"] == port_ref_vdu_id:
location_info = vdu["properties"]["location_info"]
if port["cp_id"] not in vdu["cps"]:
vdu["cps"].append(port["cp_id"])
break
if not location_info:
err_msg = "vdu_id(%s) for cp(%s) is not defined."
raise VimException(err_msg % (port_ref_vdu_id, port["cp_id"]),
ERR_CODE)
network_id = ignore_case_get(port, "networkId")
subnet_id = ignore_case_get(port, "subnetId")
if not network_id:
if port["vl_id"] == "":
return
network_id = get_res_id(res_cache, RES_NETWORK, port["vl_id"])
subnet_id = get_res_id(res_cache, RES_SUBNET, port["vl_id"])
param = {"networkId": network_id, "name": port["cp_id"]}
set_opt_val(param, "subnetId", subnet_id)
set_opt_val(param, "macAddress",
ignore_case_get(port["properties"], "mac_address"))
ip_address = []
logger.debug("port['properties']:%s" % port["properties"])
for one_protocol_data in port["properties"]["protocol_data"]:
l3_address_data = one_protocol_data["address_data"][
"l3_address_data"] # l3 is not 13
fixed_ip_address = ignore_case_get(l3_address_data, "fixed_ip_address")
ip_address.extend(fixed_ip_address)
for one_virtual_network_interface in port["properties"].get(
"virtual_network_interface_requirements", []):
network_interface_requirements = one_virtual_network_interface[
"network_interface_requirements"]
interfaceTypeString = ignore_case_get(network_interface_requirements,
"interfaceType")
interfaceType = ""
if interfaceTypeString != "":
interfaceType = json.loads(
interfaceTypeString)["configurationValue"]
vnic_type = ignore_case_get(port["properties"], "vnic_type")
if vnic_type == "":
if interfaceType == "SR-IOV":
set_opt_val(param, "vnicType", "direct")
else:
set_opt_val(param, "vnicType", vnic_type)
set_opt_val(param, "ip", ",".join(ip_address))
set_opt_val(param, "securityGroups", "") # TODO
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_port(vim_id, tenant_id, param)
ret["nodeId"] = port["cp_id"]
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, port["cp_id"], ret["id"])
def get_and_check_params(self):
ns_info = NSInstModel.objects.filter(id=self.ns_instance_id)
if not ns_info:
errmsg = 'NS [id=%s] does not exist' % self.ns_instance_id
raise NSLCMException(errmsg)
self.heal_ns_data = ignore_case_get(self.request_data, 'healNsData')
self.heal_vnf_data = ignore_case_get(self.request_data, 'healVnfData')
if self.heal_ns_data and self.heal_vnf_data:
errmsg = 'healNsData and healVnfData can not exist together'
logger.error(errmsg)
raise NSLCMException(errmsg)
if not self.heal_ns_data and not self.heal_vnf_data:
errmsg = 'healNsData and healVnfData parameters does not exist or value is incorrect.'
raise NSLCMException(errmsg)
def set_vl_vim_id(vim_id, vnf_vim, plan_dict):
if "vls" not in plan_dict:
logger.debug("No vl is found in nsd.")
return
vl_vnf = {}
for vnf in ignore_case_get(plan_dict, "vnfs"):
if "dependencies" in vnf:
for depend in vnf["dependencies"]:
vl_vnf[depend["vl_id"]] = vnf['properties']['id']
for vl in plan_dict["vls"]:
vnfdid = ignore_case_get(vl_vnf, vl["vl_id"])
vimid = ignore_case_get(vnf_vim, vnfdid)
if not vimid:
vimid = vim_id
if "location_info" not in vl["properties"]:
vl["properties"]["location_info"] = {}
vl["properties"]["location_info"]["vimid"] = vimid
def nf_delete_pending_csar(request, *args, **kwargs):
logger.info("Enter %s%s, method is %s", fun_name(), args, request.method)
csar_id = ignore_case_get(kwargs, "csarId")
job_id = str(uuid.uuid4())
nf_package.NfPkgDeletePendingThread(csar_id, job_id).start()
ret = {"jobId": job_id}
logger.info("Leave %s, Return value is %s", fun_name(), str(ret))
return Response(data=ret, status=status.HTTP_202_ACCEPTED)
def post(self, request, ns_instance_id):
logger.debug("Enter TerminateNSView::post %s", request.data)
termination_type = ignore_case_get(request.data, 'terminationType')
graceful_termination_timeout = ignore_case_get(
request.data, 'gracefulTerminationTimeout')
job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF,
ns_instance_id)
try:
TerminateNsService(ns_instance_id, termination_type,
graceful_termination_timeout, job_id).start()
except Exception as e:
logger.error("Exception in CreateNS: %s", e.message)
return Response(data={'error': e.message},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
ret = {'jobId': job_id}
logger.debug("Leave TerminateNSView::post ret=%s", ret)
return Response(data=ret, status=status.HTTP_202_ACCEPTED)
def create_port(vim_cache, res_cache, data, port, do_notify, res_type):
location_info = None
port_ref_vdu_id = ignore_case_get(port, "vdu_id")
for vdu in ignore_case_get(data, "vdus"):
if vdu["vdu_id"] == port_ref_vdu_id:
location_info = vdu["properties"]["location_info"]
if port["cp_id"] not in vdu["cps"]:
vdu["cps"].append(port["cp_id"])
break
if not location_info:
err_msg = "vdu_id(%s) for cp(%s) is not defined"
raise VimException(err_msg % (port_ref_vdu_id, port["cp_id"]),
ERR_CODE)
network_id = ignore_case_get(port, "networkId")
subnet_id = ignore_case_get(port, "subnetId")
if not network_id:
network_id = get_res_id(res_cache, RES_NETWORK, port["vl_id"])
subnet_id = get_res_id(res_cache, RES_SUBNET, port["vl_id"])
param = {
"networkId": network_id,
"name": port["properties"].get("name", "undefined")
}
set_opt_val(param, "subnetId", subnet_id)
set_opt_val(param, "macAddress",
ignore_case_get(port["properties"], "mac_address"))
set_opt_val(param, "ip", ignore_case_get(port["properties"], "ip_address"))
set_opt_val(param, "vnicType",
ignore_case_get(port["properties"], "vnic_type"))
set_opt_val(param, "securityGroups", "") # TODO
vim_id, tenant_name = location_info["vimid"], location_info["tenant"]
tenant_id = get_tenant_id(vim_cache, vim_id, tenant_name)
ret = api.create_port(vim_id, tenant_id, param)
ret["nodeId"] = port["cp_id"]
do_notify(res_type, ret)
set_res_cache(res_cache, res_type, port["cp_id"], ret["id"])
def update_Vl(self):
for vl in self.affectedVl:
vlInstanceId = ignore_case_get(vl, 'vlInstanceId')
vldid = ignore_case_get(vl, 'vldId')
changeType = ignore_case_get(vl, 'changeType')
networkResource = ignore_case_get(vl, 'networkResource')
resourceType = ignore_case_get(networkResource, 'resourceType')
resourceId = ignore_case_get(networkResource, 'resourceId')
resourceName = ignore_case_get(networkResource, 'resourceName')
if resourceType != 'network':
self.exception(
'affectedVl struct error: resourceType not euqal network')
ownerId = self.get_vnfinstid(self.m_vnfInstanceId, self.vnfmid)
if changeType == 'ADDED':
VLInstModel(vlinstanceid=vlInstanceId,
vldid=vldid,
vlinstancename=resourceName,
ownertype=0,
ownerid=ownerId,
relatednetworkid=resourceId,
vltype=0).save()
elif changeType == 'REMOVED':
VLInstModel.objects.filter(vlinstanceid=vlInstanceId).delete()
elif changeType == 'MODIFIED':
VLInstModel.objects.filter(vlinstanceid=vlInstanceId)\
.update(vldid=vldid, vlinstancename=resourceName, ownertype=0, ownerid=ownerId,
relatednetworkid=resourceId, vltype=0)
else:
self.exception(
'affectedVl struct error: changeType not in {added,removed,modified}'
)
def __init__(self, data, nf_inst_id, job_id):
super(TermVnf, self).__init__()
self.data = data
self.nf_inst_id = nf_inst_id
self.job_id = job_id
self.terminationType = ignore_case_get(self.data, "terminationType")
self.gracefulTerminationTimeout = ignore_case_get(
self.data, "gracefulTerminationTimeout")
self.apply_result = None
self.notify_data = None
self.inst_resource = {
'volumn': [],
'network': [],
'subnet': [],
'port': [],
'flavor': [],
'vm': [],
}
def build_vls(input_data):
ns_inst_id = ignore_case_get(input_data, "nsInstanceId")
nsd_json = json.JSONDecoder().decode(
ignore_case_get(input_data, "object_context"))
ns_param_json = ignore_case_get(input_data, "object_additionalParamForNs")
vl_count = int(ignore_case_get(input_data, "vlCount", 0))
vls = {}
for i in range(vl_count):
data = {
"nsInstanceId": ns_inst_id,
"vlIndex": i,
"context": nsd_json,
"additionalParamForNs": ns_param_json
}
key = nsd_json["vls"][i - 1]["vl_id"]
vls[key] = {"type": "CreateVl", "input": {"content": data}}
return vls
def apply_grant(self):
logger.debug("Start change flavour apply grant")
vdus = ignore_case_get(self.vnfd_info, "vdus")
grant_result = grant_resource(data=self.data,
nf_inst_id=self.nf_inst_id,
job_id=self.job_id,
grant_type=GRANT_TYPE.CHANGE_FLAVOUR,
vdus=vdus)
logger.debug("Change flavour Grant result: %s", grant_result)
def do_inst_vnf(self):
self.update_job(30, "Start inst vnf.")
vnf_param = ignore_case_get(self.verify_config, "additionalParamForVnf")
if vnf_param and "additionalParam" in vnf_param[0]:
vnf_param[0]["additionalParam"]["vimId"] = ignore_case_get(self.verify_config, "lab_vim_id")
inst_data = {
"nsInstanceId": "",
"additionalParamForVnf": vnf_param,
"vnfIndex": "1"
}
ret = req_by_msb("/openoapi/nslcm/v1/ns/vnfs", "POST", json.JSONEncoder().encode(inst_data))
if ret[0] != 0:
raise NSLCMException("Failed to call inst vnf: %s" % ret[1])
rsp_data = json.JSONDecoder().decode(ret[1])
self.vnf_inst_id = rsp_data["vnfInstId"]
if not self.wait_until_job_done(rsp_data["jobId"], 40):
raise NSLCMException("Vnf(%s) inst failed" % self.vnf_inst_id)
self.update_job(50, "Inst vnf success.")
def get_scale_vnf_data_from_json(scalingmap_json, nsd_id, aspect, step):
scale_options = ignore_case_get(scalingmap_json, "scale_options")
for i in range(scale_options.__len__()):
ns_scale_option = scale_options[i]
if (ignore_case_get(ns_scale_option,
"nsd_id") == nsd_id) and (ignore_case_get(
ns_scale_option, "ns_scale_aspect") == aspect):
ns_scale_info_list = ignore_case_get(ns_scale_option,
"ns_scale_info")
for j in range(ns_scale_info_list.__len__()):
ns_scale_info = ns_scale_info_list[j]
if ns_scale_info["step"] == step:
vnf_scale_info_list = ns_scale_info["vnf_scale_info"]
return vnf_scale_info_list
logger.error("get_scale_vnf_data_from_json method retuan null")
return None
def query_csar_from_catalog(csar_id, key=''):
ret = req_by_msb("/openoapi/catalog/v1/csars/%s" % csar_id, "GET")
if ret[0] != 0:
logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
if ret[2] == '404':
raise NSLCMException("CSAR(%s) does not exist." % csar_id)
raise NSLCMException("Failed to query CSAR(%s) from catalog." % csar_id)
csar_info = json.JSONDecoder().decode(ret[1])
return ignore_case_get(csar_info, key) if key else csar_info
def set_state_csar(self, csar_id, operation):
if not NSDModel.objects.filter(id=csar_id):
raise NSLCMException("CSAR(%s) does not exist." % csar_id)
csar = query_csar_from_catalog(csar_id)
if ignore_case_get(csar, "operationalState") == operation.capitalize():
raise NSLCMException("CSAR(%s) already %s." % (csar_id, operation))
return set_csar_state(csar_id, 'operationState',
operation.capitalize())
def volume_save(job_id, nf_inst_id, ret):
JobUtil.add_job_status(job_id, 25, 'Create vloumns!')
StorageInstModel.objects.create(
storageid=str(uuid.uuid4()),
vimid=ignore_case_get(ret, "vimId"),
resourceid=ignore_case_get(ret, "id"),
name=ignore_case_get(ret, "name"),
tenant=ignore_case_get(ret, "tenantId"),
create_time=ignore_case_get(ret, "createTime"),
storagetype=get_none(ignore_case_get(ret, "type")),
size=ignore_case_get(ret, "size"),
insttype=0,
is_predefined=ignore_case_get(ret, "returnCode"),
nodeId=ignore_case_get(ret, "nodeId"),
instid=nf_inst_id)
def __init__(self, data):
self.owner_id = ignore_case_get(data, "nsInstanceId")
self.index = int(float(ignore_case_get(data, "vlIndex")))
self.context = ignore_case_get(data, "context")
self.additionalParam = ignore_case_get(data, "additionalParamForNs")
self.vl_inst_id = str(uuid.uuid4())
self.owner_type = OWNER_TYPE.NS
self.vld_id = ""
self.vl_properties = ""
self.vl_profile = ""
self.vl_inst_name = ""
self.related_network_id = ""
self.related_subnetwork_id = ""
self.vim_id = ""
self.vim_name = ""
self.tenant = ""
self.description = ""
self.route_external = ""
self.ns_name = ""
def send_nf_terminate_to_vnfmDriver(self):
req_param = json.JSONEncoder().encode({
'terminationType':
self.terminationType,
'gracefulTerminationTimeout':
self.gracefulTerminationTimeout
})
rsp = send_nf_terminate_request(self.vnfm_inst_id, self.vnf_uuid,
req_param)
self.vnfm_job_id = ignore_case_get(rsp, 'jobId')
def get_and_check_params(self):
ns_info = NSInstModel.objects.filter(id=self.ns_instance_id)
if not ns_info:
raise NSLCMException('NS [id=%s] does not exist' %
self.ns_instance_id)
self.update_type = ignore_case_get(self.request_data, "updateType")
if not self.update_type:
raise NSLCMException(
'UpdateType parameter does not exist or value incorrect.')
def __init__(self, data):
self.data = data
self.filter = ignore_case_get(self.data, "filter", {})
self.callback_uri = ignore_case_get(self.data, "callbackUri")
self.authentication = ignore_case_get(self.data, "authentication", {})
self.notification_types = ignore_case_get(self.filter,
"notificationTypes", [])
self.operation_types = ignore_case_get(self.filter, "operationTypes",
[])
self.operation_states = ignore_case_get(self.filter,
"notificationStates", [])
self.ns_component_types = ignore_case_get(self.filter,
"nsComponentTypes", [])
self.lcm_opname_impacting_nscomponent = ignore_case_get(
self.filter, "lcmOpNameImpactingNsComponent", [])
self.lcm_opoccstatus_impacting_nscomponent = ignore_case_get(
self.filter, "lcmOpOccStatusImpactingNsComponent", [])
self.ns_filter = ignore_case_get(self.filter,
"nsInstanceSubscriptionFilter", {})
def convert_sdnc_info(sdnc_info_aai):
esr_system_info = ignore_case_get(
ignore_case_get(sdnc_info_aai, "esr-system-info-list"),
"esr-system-info")
sdnc_info = {
"sdnControllerId": sdnc_info_aai["thirdparty-sdnc-id"],
"name": sdnc_info_aai["thirdparty-sdnc-id"],
"url": ignore_case_get(esr_system_info[0], "service-url"),
"userName": ignore_case_get(esr_system_info[0], "user-name"),
"password": ignore_case_get(esr_system_info[0], "password"),
"vendor": ignore_case_get(esr_system_info[0], "vendor"),
"version": ignore_case_get(esr_system_info[0], "version"),
"description": "",
"protocol": ignore_case_get(esr_system_info[0], "protocal"),
"productName": ignore_case_get(sdnc_info_aai, "product-name"),
"type": ignore_case_get(esr_system_info[0], "type"),
"createTime": ""
}
return sdnc_info
def send_nf_healing_request(self):
req_param = json.JSONEncoder().encode(self.nf_heal_params)
rsp = send_nf_heal_request(self.vnfm_inst_id, self.m_nf_inst_id, req_param)
vnfm_job_id = ignore_case_get(rsp, 'jobId')
if not vnfm_job_id:
return
ret = wait_job_finish(self.vnfm_inst_id, self.job_id, vnfm_job_id, progress_range=None, timeout=1200, mode='1')
if ret != JOB_MODEL_STATUS.FINISHED:
logger.error('[NF heal] nf heal failed')
raise NSLCMException("nf heal failed")
def ns_delete_pending_csar(request, *args, **kwargs):
csar_id = ignore_case_get(kwargs, "csarId")
logger.info("Enter %s, method is %s, csar_id is %s", fun_name(),
request.method, csar_id)
ret = ns_package.ns_delete_pending_csar(csar_id)
logger.info("Leave %s, Return value is %s", fun_name(), str(ret))
if ret[0] != 0:
return Response(data={'error': ret[1]},
status=status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(data=ret[1], status=status.HTTP_202_ACCEPTED)
def update_cps(self):
for extlink in ignore_case_get(self.data, "extVirtualLinks"):
for ext_cp in ignore_case_get(extlink, "extCps"):
cpdid = ignore_case_get(ext_cp, "cpdId")
for cp in ignore_case_get(self.vnfd_info, "cps"):
if cpdid == ignore_case_get(cp, "cp_id"):
cp["networkId"] = ignore_case_get(extlink, "resourceId")
cp["subnetId"] = ignore_case_get(extlink, "resourceSubnetId")
break
def __init__(self, data, nf_inst_id, job_id):
super(InstantiateVnf, self).__init__()
self.data = data
self.nf_inst_id = nf_inst_id
self.job_id = job_id
self.vim_id = ignore_case_get(
ignore_case_get(
self.data,
"additionalParams"
),
"vimId"
)
self.grant_type = GRANT_TYPE.INSTANTIATE
self.lcm_op_occ = VnfLcmOpOcc(
vnf_inst_id=nf_inst_id,
lcm_op_id=job_id,
operation=OPERATION_TYPE.INSTANTIATE,
task=OPERATION_TASK.INSTANTIATE
)
self.pre_deal()
def get(self, request, job_id):
try:
response_id = ignore_case_get(request.META, 'responseId')
ret = GetJobInfoService(job_id, response_id).do_biz()
resp_serializer = JobQueryRespSerializer(data=ret)
if not resp_serializer.is_valid():
raise NFLCMException(resp_serializer.errors)
return Response(data=ret, status=status.HTTP_200_OK)
except Exception as e:
logger.error(traceback.format_exc())
return Response(data={'error': e.args[0]}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
