X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=zte%2Fvmanager%2Fdriver%2Finterfaces%2Fviews.py;h=7376d4d2b63714bb7e8eea41527bb4fc10ef7052;hb=1666778165fcf65c8a7820553c31f60a2433c5fd;hp=21432b2f8399f6430aa8645fe6dc8c0b1b2c2282;hpb=6fd09a47ab75b0f8177db35c9ded5aefb85e0aa8;p=vfc%2Fnfvo%2Fdriver%2Fvnfm%2Fsvnfm.git diff --git a/zte/vmanager/driver/interfaces/views.py b/zte/vmanager/driver/interfaces/views.py index 21432b2f..7376d4d2 100644 --- a/zte/vmanager/driver/interfaces/views.py +++ b/zte/vmanager/driver/interfaces/views.py @@ -15,15 +15,24 @@ import inspect import json import logging -import traceback import os +import traceback -from rest_framework.decorators import api_view +from drf_yasg import openapi +from drf_yasg.utils import swagger_auto_schema +from rest_framework import status from rest_framework.response import Response +from rest_framework.views import APIView +from django.http import StreamingHttpResponse +from driver.interfaces.serializers import HealReqSerializer, InstScaleHealRespSerializer, ScaleReqSerializer, \ + NotifyReqSerializer, GrantRespSerializer, GrantReqSerializer, JobQueryRespSerializer, TerminateVnfRequestSerializer, \ + InstantiateVnfRequestSerializer, QueryVnfResponseSerializer +from driver.pub.config.config import VNF_FTP from driver.pub.utils import restcall from driver.pub.utils.restcall import req_by_msb -from driver.pub.config.config import VNF_FTP + +CHUNK_SIZE = 1024 * 8 logger = logging.getLogger(__name__) @@ -36,6 +45,25 @@ def load_json_file(file_name): return json_data +def read(file_path, start, end): + fp = open(file_path, 'rb') + fp.seek(start) + pos = start + while pos + CHUNK_SIZE < end: + yield fp.read(CHUNK_SIZE) + pos = fp.tell() + yield fp.read(end - pos) + + +def parse_file_range(file_path, file_range): + start, end = 0, os.path.getsize(file_path) + if file_range: + [start, end] = file_range.split('-') + start, end = start.strip(), end.strip() + start, end = int(start), int(end) + return start, end + + def fun_name(): return "=================%s==================" % inspect.stack()[1][3] @@ -53,19 +81,6 @@ def ignorcase_get(args, key): return "" -def mapping_conv(keyword_map, rest_return): - resp_data = {} - for param in keyword_map: - if keyword_map[param]: - resp_data[keyword_map[param]] = ignorcase_get(rest_return, param) - return resp_data - - -query_vnfd_url = "api/nslcm/v1/vnfpackage/%s" -query_vnfm_url = "api/extsys/v1/vnfms/%s" -query_package_url = "api/nslcm/v1/vnfpackage/%s" - - # Query vnfm_info from nslcm def get_vnfminfo_from_nslcm(vnfmid): ret = req_by_msb("api/nslcm/v1/vnfms/%s" % vnfmid, "GET") @@ -84,468 +99,516 @@ def vnfpackage_get(csarid): return ret -create_vnf_url = "v1/vnfs" -create_vnf_param_mapping = { - "packageUrl": "", - "instantiateUrl": "", - "instantiationLevel": "", - "vnfInstanceName": "", - "vnfPackageId": "", - "vnfDescriptorId": "", - "flavorId": "", - "vnfInstanceDescription": "", - "extVirtualLink": "", - "additionalParam": ""} -create_vnf_resp_mapping = { - "VNFInstanceID": "vnfInstanceId", - "JobId": "jobid" -} - - -@api_view(http_method_names=['POST']) -def instantiate_vnf(request, *args, **kwargs): - try: - logger.debug("[%s] request.data=%s", fun_name(), request.data) - vnfm_id = ignorcase_get(kwargs, "vnfmid") - ret = get_vnfminfo_from_nslcm(vnfm_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnfm_info = json.JSONDecoder().decode(ret[1]) - logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) - vnf_package_id = ignorcase_get(request.data, "vnfPackageId") - ret = vnfd_get(vnf_package_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnfd_info = json.JSONDecoder().decode(ret[1]) - logger.debug("[%s] vnfd_info=%s", fun_name(), vnfd_info) - csar_id = ignorcase_get(vnfd_info, "csarId") - ret = vnfpackage_get(csar_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnf_package_info = json.JSONDecoder().decode(ret[1]) - packageInfo = ignorcase_get(vnf_package_info, "packageInfo") - logger.debug("[%s] packageInfo=%s", fun_name(), packageInfo) - data = {} - data["NFVOID"] = 1 - data["VNFMID"] = vnfm_id - # vnfdId = ignorcase_get(packageInfo, "vnfdId") - vnfdModel = json.loads(ignorcase_get(packageInfo, "vnfdModel")) - metadata = ignorcase_get(vnfdModel, "metadata") - vnfd_name = ignorcase_get(metadata, "name") - # TODO convert sdc vnf package to vnf vender package - - inputs = [] - if "SPGW" in vnfd_name.upper(): - data["VNFD"] = VNF_FTP + "SPGW" - inputs = load_json_file("SPGW" + "_inputs.json") - elif "MME" in vnfd_name.upper(): - data["VNFD"] = VNF_FTP + "MME" - inputs = load_json_file("MME" + "_inputs.json") - else: - data["VNFD"] = ignorcase_get(packageInfo, "downloadUri") - - data["VNFURL"] = data["VNFD"] - - data["extension"] = {} - for name, value in ignorcase_get(ignorcase_get(request.data, "additionalParam"), "inputs").items(): - inputs.append({"name": name, "value": value}) - - logger.info( - "ignorcase_get(request.data, \"additionalParam\") = %s" % ignorcase_get(request.data, "additionalParam")) - data["extension"]["inputs"] = json.dumps(inputs) - data["extension"]["extVirtualLinks"] = ignorcase_get( - ignorcase_get(request.data, "additionalParam"), "extVirtualLinks") - data["extension"]["vnfinstancename"] = ignorcase_get(request.data, "vnfInstanceName") - data["extension"]["vnfid"] = data["VNFD"] - data["extension"]["multivim"] = 0 - logger.debug("[%s] call_req data=%s", fun_name(), data) - - ret = restcall.call_req( - base_url=ignorcase_get(vnfm_info, "url"), - user=ignorcase_get(vnfm_info, "userName"), - passwd=ignorcase_get(vnfm_info, "password"), - auth_type=restcall.rest_no_auth, - resource=create_vnf_url, - method='post', - content=json.JSONEncoder().encode(data)) - - logger.debug("[%s] call_req ret=%s", fun_name(), ret) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - resp = json.JSONDecoder().decode(ret[1]) - resp_data = mapping_conv(create_vnf_resp_mapping, resp) - logger.info("[%s]resp_data=%s", fun_name(), resp_data) - except Exception as e: - logger.error("Error occurred when instantiating VNF") - raise e - return Response(data=resp_data, status=ret[2]) - - -vnf_delete_url = "v1/vnfs/%s" -vnf_delete_param_mapping = { - "terminationType": "terminationType", - "gracefulTerminationTimeout": "gracefulTerminationTimeout"} -vnf_delete_resp_mapping = { - "vnfInstanceId": "vnfInstanceId", - "JobId": "jobid"} - - -@api_view(http_method_names=['POST']) -def terminate_vnf(request, *args, **kwargs): - try: - logger.debug("[%s] request.data=%s", fun_name(), request.data) - vnfm_id = ignorcase_get(kwargs, "vnfmid") - ret = get_vnfminfo_from_nslcm(vnfm_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnfm_info = json.JSONDecoder().decode(ret[1]) - logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) - data = {} - logger.debug("[%s]req_data=%s", fun_name(), data) - ret = restcall.call_req( - base_url=ignorcase_get(vnfm_info, "url"), - user=ignorcase_get(vnfm_info, "userName"), - passwd=ignorcase_get(vnfm_info, "password"), - auth_type=restcall.rest_no_auth, - resource=vnf_delete_url % (ignorcase_get(kwargs, "vnfInstanceID")), - method='delete', - content=json.JSONEncoder().encode(data)) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - resp = json.JSONDecoder().decode(ret[1]) - resp_data = mapping_conv(vnf_delete_resp_mapping, resp) - logger.debug("[%s]resp_data=%s", fun_name(), resp_data) - except Exception as e: - logger.error("Error occurred when terminating VNF") - raise e - return Response(data=resp_data, status=ret[2]) - - -vnf_detail_url = "v1/vnfs/%s" -vnf_detail_resp_mapping = { - "VNFInstanseStatus": "status" -} - - -@api_view(http_method_names=['GET']) -def query_vnf(request, *args, **kwargs): - try: - logger.debug("[%s] request.data=%s", fun_name(), request.data) - vnfm_id = ignorcase_get(kwargs, "vnfmid") - ret = get_vnfminfo_from_nslcm(vnfm_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnfm_info = json.JSONDecoder().decode(ret[1]) - logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) - data = {} - ret = restcall.call_req( - base_url=ignorcase_get(vnfm_info, "url"), - user=ignorcase_get(vnfm_info, "userName"), - passwd=ignorcase_get(vnfm_info, "password"), - auth_type=restcall.rest_no_auth, - resource=vnf_detail_url % (ignorcase_get(kwargs, "vnfInstanceID")), - method='get', - content=json.JSONEncoder().encode(data)) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - resp = json.JSONDecoder().decode(ret[1]) - vnf_status = ignorcase_get(resp, "vnfinstancestatus") - resp_data = {"vnfInfo": {"vnfStatus": vnf_status}} - logger.debug("[%s]resp_data=%s", fun_name(), resp_data) - except Exception as e: - logger.error("Error occurred when querying VNF information.") - raise e - return Response(data=resp_data, status=ret[2]) - - -# Get Operation Status -operation_status_url = '/v1/jobs/{jobId}?NFVOID={nfvoId}&VNFMID={vnfmId}&ResponseID={responseId}' -operation_status_resp_map = { - "JobId": "jobId", - "Status": "status", - "Progress": "progress", - "StatusDescription": "currentStep", - "ErrorCode": "errorCode", - "ResponseId": "responseId", - "ResponseHistoryList": "responseHistoryList", - "ResponseDescriptor": "responseDescriptor" -} - - -@api_view(http_method_names=['GET']) -def operation_status(request, *args, **kwargs): - data = {} - try: - logger.debug("[%s] request.data=%s", fun_name(), request.data) - vnfm_id = ignorcase_get(kwargs, "vnfmid") - ret = get_vnfminfo_from_nslcm(vnfm_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnfm_info = json.JSONDecoder().decode(ret[1]) - logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) - ret = restcall.call_req( - base_url=ignorcase_get(vnfm_info, 'url'), - user=ignorcase_get(vnfm_info, 'userName'), - passwd=ignorcase_get(vnfm_info, 'password'), - auth_type=restcall.rest_no_auth, - resource=operation_status_url.format(jobId=ignorcase_get(kwargs, 'jobid'), nfvoId=1, - vnfmId=ignorcase_get(kwargs, 'vnfmid'), - responseId=ignorcase_get(request.GET, 'responseId')), - method='get', - content=json.JSONEncoder().encode(data)) - - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - resp_data = json.JSONDecoder().decode(ret[1]) - logger.info("[%s]resp_data=%s", fun_name(), resp_data) - except Exception as e: - logger.error("Error occurred when getting operation status information.") - raise e - return Response(data=resp_data, status=ret[2]) - - -# Grant VNF Lifecycle Operation -grant_vnf_url = 'api/nslcm/v1/ns/grantvnf' -grant_vnf_param_map = { - "VNFMID": "", - "NFVOID": "", - "VIMID": "", - "ExVIMIDList": "", - "ExVIMID": "", - "Tenant": "", - "VNFInstanceID": "vnfInstanceId", - "OperationRight": "", - "VMList": "", - "VMFlavor": "", - "VMNumber": ""} - - -@api_view(http_method_names=['PUT']) -def grantvnf(request, *args, **kwargs): - logger.info("=====grantvnf=====") - try: - resp_data = {} - logger.info("req_data = %s", request.data) - data = mapping_conv(grant_vnf_param_map, request.data) - logger.info("grant_vnf_url = %s", grant_vnf_url) - data["vnfDescriptorId"] = "" - if ignorcase_get(request.data, "operationright") == 0: - data["lifecycleOperation"] = "Instantiate" - data["addresource"] = [] - for vm in ignorcase_get(request.data, "vmlist"): - for i in range(int(ignorcase_get(vm, "vmnumber"))): - data["addresource"].append( - {"type": "vdu", - "resourceDefinitionId": i, - "vdu": ignorcase_get(vm, "vmflavor"), - "vimid": ignorcase_get(vm, "vimid"), - "tenant": ignorcase_get(vm, "tenant") - }) - - data["additionalparam"] = {} - data["additionalparam"]["vnfmid"] = ignorcase_get(request.data, "vnfmid") - data["additionalparam"]["vimid"] = ignorcase_get(request.data, "vimid") - data["additionalparam"]["tenant"] = ignorcase_get(request.data, "tenant") - - logger.info("data = %s", data) - ret = req_by_msb(grant_vnf_url, "POST", content=json.JSONEncoder().encode(data)) - logger.info("ret = %s", ret) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - resp = json.JSONDecoder().decode(ret[1]) - - resp_data['vimid'] = ignorcase_get(resp['vim'], 'vimid') - resp_data['tenant'] = ignorcase_get(ignorcase_get(resp['vim'], 'accessinfo'), 'tenant') - - logger.info("[%s]resp_data=%s", fun_name(), resp_data) - except Exception as e: - logger.error("Error occurred in Grant VNF.") - raise e - return Response(data=resp_data, status=ret[2]) - - -# Notify LCM Events -notify_url = 'api/nslcm/v1/ns/{vnfmid}/vnfs/{vnfInstanceId}/Notify' -notify_param_map = { - "NFVOID": "", - "VNFMID": "VNFMID", - "VIMID": "vimid", - "VNFInstanceID": "vnfInstanceId", - "TimeStamp": "", - "EventType": "operation", - "VMList": "", - "VMFlavor": "", - "VMNumber": "", - "VMIDlist": "", - "VMUUID": "" -} - - -@api_view(http_method_names=['POST']) -def notify(request, *args, **kwargs): - try: - logger.info("[%s]req_data = %s", fun_name(), request.data) - data = mapping_conv(notify_param_map, request.data) - logger.info("[%s]data = %s", fun_name(), data) - - data["status"] = "result" - data["jobId"] = "notMust" - data["affectedVnfc"] = [] - data["affectedVl"] = [] - data["affectedVirtualStorage"] = [] - data["affectedCp"] = [] - - extension = ignorcase_get(request.data, "extension") - openo_notification = ignorcase_get(extension, "openo_notification") - if openo_notification: - affectedvnfcs = ignorcase_get(openo_notification, "affectedVnfc") - affectedvls = ignorcase_get(openo_notification, "affectedvirtuallink") - affectedcps = ignorcase_get(openo_notification, "affectedCp") - vnfdmodule = ignorcase_get(openo_notification, "vnfdmodule") - else: - affectedvnfcs = ignorcase_get(ignorcase_get(request.data, "extension"), "affectedvnfc") - affectedvls = ignorcase_get(ignorcase_get(request.data, "extension"), "affectedvl") - affectedcps = ignorcase_get(ignorcase_get(request.data, "extension"), "affectedcp") - vnfdmodule = ignorcase_get(ignorcase_get(request.data, "extension"), "vnfdmodule") - - data["vnfdmodule"] = vnfdmodule - - for affectedvnfc in affectedvnfcs: - data["affectedVnfc"].append({ - "vnfcInstanceId": ignorcase_get(affectedvnfc, "vnfcInstanceId"), - "vduId": ignorcase_get(affectedvnfc, "vduId"), - "changeType": ignorcase_get(affectedvnfc, "changeType"), - "vimid": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "vimId"), - "vmId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceId"), - "vmName": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceName") - }) - - for affectedvl in affectedvls: - data["affectedVl"].append({ - "vlInstanceId": ignorcase_get(affectedvl, "virtuallinkinstanceid"), - "vimid": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "vimid"), - "vldid": ignorcase_get(affectedvl, "virtuallinkdescid"), - "vllid": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourceid"), - "vlName": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourcename") - }) - - for affectedcp in affectedcps: - data["affectedCp"].append(affectedcp) - - ret = req_by_msb(notify_url.format(vnfmid=ignorcase_get(data, 'VNFMID'), - vnfInstanceId=ignorcase_get(data, 'vnfinstanceid')), - "POST", content=json.JSONEncoder().encode(data)) - - logger.info("[%s]data = %s", fun_name(), ret) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - except Exception as e: - logger.error("Error occurred in LCM notification.") - logger.error(traceback.format_exc()) - raise e - return Response(data=None, status=ret[2]) - - -nf_scaling_url = '/v1/vnfs/{vnfInstanceID}/scale' - - -@api_view(http_method_names=['POST']) -def scale(request, *args, **kwargs): - logger.info("====scale_vnf===") - try: - logger.info("request.data = %s", request.data) - logger.info("requested_url = %s", request.get_full_path()) - vnfm_id = ignorcase_get(kwargs, "vnfmid") - nf_instance_id = ignorcase_get(kwargs, "vnfInstanceId") - ret = get_vnfminfo_from_nslcm(vnfm_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnfm_info = json.JSONDecoder().decode(ret[1]) - scale_type = ignorcase_get(request.data, "type") - aspect_id = ignorcase_get(request.data, "aspectId") - number_of_steps = ignorcase_get(request.data, "numberOfSteps") - # extension = ignorcase_get(request.data, "additionalParam") - # vnfd_model = ignorcase_get(extension, "vnfdModel") - data = { - 'vnfmid': vnfm_id, - 'nfvoid': 1, - 'scaletype': '0' if scale_type == 'SCALE_OUT' else '1', - 'vmlist': [{'VMNumber': number_of_steps, 'VMFlavor': aspect_id}], - 'extension': '' +class InstantiateVnf(APIView): + @swagger_auto_schema( + request_body=InstantiateVnfRequestSerializer(), + responses={ + status.HTTP_200_OK: InstScaleHealRespSerializer(), + status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error" + } + ) + def post(self, request, vnfmid): + try: + logger.debug("[%s] request.data=%s", fun_name(), request.data) + instantiateVnfRequestSerializer = InstantiateVnfRequestSerializer(data=request.data) + if not instantiateVnfRequestSerializer.is_valid(): + raise Exception(instantiateVnfRequestSerializer.errors) + + ret = get_vnfminfo_from_nslcm(vnfmid) + if ret[0] != 0: + raise Exception(ret[1]) + + vnfm_info = json.JSONDecoder().decode(ret[1]) + logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) + vnf_package_id = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfPackageId") + ret = vnfd_get(vnf_package_id) + if ret[0] != 0: + raise Exception(ret[1]) + + vnfd_info = json.JSONDecoder().decode(ret[1]) + logger.debug("[%s] vnfd_info=%s", fun_name(), vnfd_info) + csar_id = ignorcase_get(vnfd_info, "csarId") + ret = vnfpackage_get(csar_id) + if ret[0] != 0: + raise Exception(ret[1]) + + vnf_package_info = json.JSONDecoder().decode(ret[1]) + packageInfo = ignorcase_get(vnf_package_info, "packageInfo") + logger.debug("[%s] packageInfo=%s", fun_name(), packageInfo) + data = { + "NFVOID": 1, + "VNFMID": vnfmid, + "extension": {}, + } + vnfdModel = json.loads(ignorcase_get(packageInfo, "vnfdModel")) + metadata = ignorcase_get(vnfdModel, "metadata") + vnfd_name = ignorcase_get(metadata, "name") + # TODO convert sdc vnf package to vnf vender package + inputs = [] + if "SPGW" in vnfd_name.upper(): + data["VNFD"] = VNF_FTP + "SPGW" + inputs = load_json_file("SPGW" + "_inputs.json") + elif "MME" in vnfd_name.upper(): + data["VNFD"] = VNF_FTP + "MME" + inputs = load_json_file("MME" + "_inputs.json") + else: + data["VNFD"] = ignorcase_get(packageInfo, "downloadUri") + + data["VNFURL"] = data["VNFD"] + + additionalParam = ignorcase_get(instantiateVnfRequestSerializer.data, "additionalParam") + for name, value in ignorcase_get(additionalParam, "inputs").items(): + inputs.append({"name": name, "value": value}) + + data["extension"]["inputs"] = json.dumps(inputs) + data["extension"]["extVirtualLinks"] = ignorcase_get(additionalParam, "extVirtualLinks") + data["extension"]["vnfinstancename"] = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfInstanceName") + data["extension"]["vnfid"] = data["VNFD"] + data["extension"]["multivim"] = 0 + logger.debug("[%s] call_req data=%s", fun_name(), data) + + ret = restcall.call_req( + base_url=ignorcase_get(vnfm_info, "url"), + user=ignorcase_get(vnfm_info, "userName"), + passwd=ignorcase_get(vnfm_info, "password"), + auth_type=restcall.rest_no_auth, + resource="v1/vnfs", + method='post', + content=json.JSONEncoder().encode(data)) + + logger.debug("[%s] call_req ret=%s", fun_name(), ret) + if ret[0] != 0: + raise Exception(ret[1]) + + resp = json.JSONDecoder().decode(ret[1]) + resp_data = { + "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"), + "jobId": ignorcase_get(resp, "JobId") + } + logger.debug("[%s]resp_data=%s", fun_name(), resp_data) + instRespSerializer = InstScaleHealRespSerializer(data=resp_data) + if not instRespSerializer.is_valid(): + raise Exception(instRespSerializer.errors) + + logger.debug("[%s] instRespSerializer.data=%s", fun_name(), instRespSerializer.data) + return Response(data=instRespSerializer.data, status=status.HTTP_200_OK) + except Exception as e: + logger.error("Error occurred when instantiating VNF,error:%s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'InstantiateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + +class TerminateVnf(APIView): + @swagger_auto_schema( + request_body=TerminateVnfRequestSerializer(), + responses={ + status.HTTP_200_OK: InstScaleHealRespSerializer(), + status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error" + } + ) + def post(self, request, vnfmid, vnfInstanceId): + try: + logger.debug("[%s] request.data=%s", fun_name(), request.data) + terminate_vnf_request_serializer = TerminateVnfRequestSerializer(data=request.data) + if not terminate_vnf_request_serializer.is_valid(): + raise Exception(terminate_vnf_request_serializer.errors) + + ret = get_vnfminfo_from_nslcm(vnfmid) + if ret[0] != 0: + raise Exception(ret[1]) + + vnfm_info = json.JSONDecoder().decode(ret[1]) + logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) + ret = restcall.call_req( + base_url=ignorcase_get(vnfm_info, "url"), + user=ignorcase_get(vnfm_info, "userName"), + passwd=ignorcase_get(vnfm_info, "password"), + auth_type=restcall.rest_no_auth, + resource="v1/vnfs/%s" % vnfInstanceId, + method='delete', + content=json.JSONEncoder().encode(terminate_vnf_request_serializer.data)) + if ret[0] != 0: + raise Exception(ret[1]) + + resp = json.JSONDecoder().decode(ret[1]) + resp_data = { + "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"), + "jobId": ignorcase_get(resp, "JobId") + } + logger.debug("[%s]resp_data=%s", fun_name(), resp_data) + terminateRespSerializer = InstScaleHealRespSerializer(data=resp_data) + if not terminateRespSerializer.is_valid(): + raise Exception(terminateRespSerializer.errors) + return Response(data=terminateRespSerializer.data, status=status.HTTP_200_OK) + except Exception as e: + logger.error("Error occurred when terminating VNF,error: %s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'TerminateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + +class QueryVnf(APIView): + @swagger_auto_schema( + responses={ + status.HTTP_200_OK: QueryVnfResponseSerializer(), + status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error" + } + ) + def get(self, request, vnfmid, vnfInstanceId): + try: + logger.debug("[%s] request.data=%s", fun_name(), request.data) + ret = get_vnfminfo_from_nslcm(vnfmid) + if ret[0] != 0: + raise Exception(ret[1]) + + vnfm_info = json.JSONDecoder().decode(ret[1]) + logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) + ret = restcall.call_req( + base_url=ignorcase_get(vnfm_info, "url"), + user=ignorcase_get(vnfm_info, "userName"), + passwd=ignorcase_get(vnfm_info, "password"), + auth_type=restcall.rest_no_auth, + resource="v1/vnfs/%s" % vnfInstanceId, + method='get', + content=json.JSONEncoder().encode({})) + if ret[0] != 0: + raise Exception(ret[1]) + + resp = json.JSONDecoder().decode(ret[1]) + vnf_status = ignorcase_get(resp, "vnfinstancestatus") + resp_data = {"vnfInfo": {"vnfStatus": vnf_status}} + logger.debug("[%s]resp_data=%s", fun_name(), resp_data) + queryVnfResponseSerializer = QueryVnfResponseSerializer(data=resp_data) + if not queryVnfResponseSerializer.is_valid(): + raise Exception(queryVnfResponseSerializer.errors) + return Response(data=queryVnfResponseSerializer.data, status=status.HTTP_200_OK) + except Exception as e: + logger.error("Error occurred when querying VNF information,error:%s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'QueryVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + +class JobView(APIView): + @swagger_auto_schema( + manual_parameters=[ + openapi.Parameter('responseId', + openapi.IN_QUERY, + "responseId", + type=openapi.TYPE_INTEGER + ), + ], + responses={ + status.HTTP_200_OK: JobQueryRespSerializer(), + status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error" + } + ) + def get(self, request, vnfmid, jobid): + try: + logger.debug("[%s] request.data=%s", fun_name(), request.data) + ret = get_vnfminfo_from_nslcm(vnfmid) + if ret[0] != 0: + raise Exception(ret[1]) + + vnfm_info = json.JSONDecoder().decode(ret[1]) + logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info) + operation_status_url = '/v1/jobs/{jobId}?NFVOID={nfvoId}&VNFMID={vnfmId}&ResponseID={responseId}' + responseId = ignorcase_get(request.GET, 'responseId') + query_url = operation_status_url.format(jobId=jobid, nfvoId=1, vnfmId=vnfmid, responseId=responseId) + ret = restcall.call_req( + base_url=ignorcase_get(vnfm_info, 'url'), + user=ignorcase_get(vnfm_info, 'userName'), + passwd=ignorcase_get(vnfm_info, 'password'), + auth_type=restcall.rest_no_auth, + resource=query_url, + method='get', + content={}) + + if ret[0] != 0: + raise Exception(ret[1]) + + resp_data = json.JSONDecoder().decode(ret[1]) + logger.debug("[%s]resp_data=%s", fun_name(), resp_data) + jobQueryRespSerializer = JobQueryRespSerializer(data=resp_data) + if not jobQueryRespSerializer.is_valid(): + raise Exception(jobQueryRespSerializer.errors) + + return Response(data=jobQueryRespSerializer.data, status=status.HTTP_200_OK) + except Exception as e: + logger.error("Error occurred when getting operation status information,error:%s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'QueryJob expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + +class GrantVnf(APIView): + @swagger_auto_schema( + request_body=GrantReqSerializer(), + responses={ + status.HTTP_201_CREATED: GrantRespSerializer(), + status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error' } - ''' - for vdu_id in get_vdus(vnfd_model, aspect_id): - data['vmlist'].append({ - "VMFlavor": vdu_id, - "VMNumber": number_of_steps - }) - ''' - logger.info("data = %s", data) - ret = restcall.call_req( - base_url=ignorcase_get(vnfm_info, "url"), - user=ignorcase_get(vnfm_info, "userName"), - passwd=ignorcase_get(vnfm_info, "password"), - auth_type=restcall.rest_no_auth, - resource=nf_scaling_url.format(vnfInstanceID=nf_instance_id), - method='put', # POST - content=json.JSONEncoder().encode(data)) - logger.info("ret=%s", ret) - if ret[0] != 0: - return Response(data={'error': 'scale error'}, status=ret[2]) - resp_data = json.JSONDecoder().decode(ret[1]) - logger.info("resp_data=%s", resp_data) - except Exception as e: - logger.error("Error occurred when scaling VNF,error:%s", e.message) - logger.error(traceback.format_exc()) - return Response(data={'error': 'scale expection'}, status='500') - return Response(data=resp_data, status=ret[2]) - - -nf_healing_url = '/api/v1/nf_m_i/nfs/{vnfInstanceID}/vms/operation' - - -@api_view(http_method_names=['POST']) -def heal(request, *args, **kwargs): - logger.info("====heal_vnf===") - try: - logger.info("request.data = %s", request.data) - logger.info("requested_url = %s", request.get_full_path()) - vnfm_id = ignorcase_get(kwargs, "vnfmid") - nf_instance_id = ignorcase_get(kwargs, "vnfInstanceId") - ret = get_vnfminfo_from_nslcm(vnfm_id) - if ret[0] != 0: - return Response(data={'error': ret[1]}, status=ret[2]) - vnfm_info = json.JSONDecoder().decode(ret[1]) - data = {} - data['action'] = ignorcase_get(request.data, 'action') - affectedvm = ignorcase_get(request.data, 'affectedvm') - data['affectedvm'] = [] - if isinstance(affectedvm, list): - data['affectedvm'] = affectedvm - else: - data['affectedvm'].append(affectedvm) - data['lifecycleoperation'] = 'operate' - data['isgrace'] = 'force' - - logger.info("data = %s", data) - ret = restcall.call_req( - base_url=ignorcase_get(vnfm_info, "url"), - user=ignorcase_get(vnfm_info, "userName"), - passwd=ignorcase_get(vnfm_info, "password"), - auth_type=restcall.rest_no_auth, - resource=nf_healing_url.format(vnfInstanceID=nf_instance_id), - method='post', - content=json.JSONEncoder().encode(data)) - logger.info("ret=%s", ret) - if ret[0] != 0: - return Response(data={'error': 'heal error'}, status=ret[2]) - resp_data = json.JSONDecoder().decode(ret[1]) - logger.info("resp_data=%s", resp_data) - except Exception as e: - logger.error("Error occurred when healing VNF,error:%s", e.message) - logger.error(traceback.format_exc()) - return Response(data={'error': 'heal expection'}, status='500') - return Response(data=resp_data, status=ret[2]) + ) + def put(self, request): + logger.debug("=====GrantVnf=====") + try: + logger.debug("request.data = %s", request.data) + grantReqSerializer = GrantReqSerializer(data=request.data) + if not grantReqSerializer.is_valid(): + raise Exception(grantReqSerializer.errors) + + logger.debug("grantReqSerializer.data = %s", grantReqSerializer.data) + req_data = { + "vnfInstanceId": ignorcase_get(grantReqSerializer.data, "vnfistanceid"), + "vnfDescriptorId": "", + "addresource": [], + "additionalparam": { + "vnfmid": ignorcase_get(grantReqSerializer.data, "vnfmid"), + "vimid": ignorcase_get(grantReqSerializer.data, "vimid"), + "tenant": ignorcase_get(grantReqSerializer.data, "tenant") + } + } + if ignorcase_get(grantReqSerializer.data, "operationright") == 0: + req_data["lifecycleOperation"] = "Instantiate" + for vm in ignorcase_get(grantReqSerializer.data, "vmlist"): + for i in range(int(ignorcase_get(vm, "VMNumber"))): + req_data["addresource"].append( + { + "type": "vdu", + "resourceDefinitionId": i, + "vdu": ignorcase_get(vm, "VMFlavor"), + "vimid": ignorcase_get(vm, "vimid"), + "tenant": ignorcase_get(vm, "tenant")}) + + logger.debug("req_data=%s", req_data) + ret = req_by_msb('api/nslcm/v1/ns/grantvnf', "POST", content=json.JSONEncoder().encode(req_data)) + logger.info("ret = %s", ret) + if ret[0] != 0: + raise Exception(ret[1]) + + resp = json.JSONDecoder().decode(ret[1]) + resp_data = { + 'vimid': ignorcase_get(resp['vim'], 'vimid'), + 'tenant': ignorcase_get(ignorcase_get(resp['vim'], 'accessinfo'), 'tenant') + } + logger.debug("[%s]resp_data=%s", fun_name(), resp_data) + grantRespSerializer = GrantRespSerializer(data=resp_data) + if not grantRespSerializer.is_valid(): + raise Exception(grantRespSerializer.errors) + + logger.debug("grantRespSerializer.data=%s", grantRespSerializer.data) + return Response(data=grantRespSerializer.data, status=status.HTTP_201_CREATED) + except Exception as e: + logger.error("Error occurred in Grant VNF, error: %s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'Grant expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + +class Notify(APIView): + @swagger_auto_schema( + request_body=NotifyReqSerializer(), + responses={ + status.HTTP_200_OK: 'Successfully', + status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error' + } + ) + def post(self, request): + try: + logger.debug("[%s]request.data = %s", fun_name(), request.data) + notifyReqSerializer = NotifyReqSerializer(data=request.data) + if not notifyReqSerializer.is_valid(): + raise Exception(notifyReqSerializer.errors) + + logger.debug("[%s]notifyReqSerializer.data = %s", fun_name(), notifyReqSerializer.data) + req_data = { + "status": "result", + "vnfInstanceId": ignorcase_get(notifyReqSerializer.data, "vnfinstanceid"), + "vnfmId": ignorcase_get(notifyReqSerializer.data, "vnfmid"), + "vimId": ignorcase_get(notifyReqSerializer.data, "vimid"), + "operation": ignorcase_get(notifyReqSerializer.data, "EventType"), + "jobId": "notMust", + "affectedVl": [], + "affectedCp": [], + "affectedVirtualStorage": [], + "affectedVnfc": [], + } + + extension = ignorcase_get(notifyReqSerializer.data, "extension") + openo_notification = ignorcase_get(extension, "openo_notification") + if openo_notification: + affectedvnfcs = ignorcase_get(openo_notification, "affectedVnfc") + affectedvls = ignorcase_get(openo_notification, "affectedvirtuallink") + affectedcps = ignorcase_get(openo_notification, "affectedCp") + vnfdmodule = ignorcase_get(openo_notification, "vnfdmodule") + else: + affectedvnfcs = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvnfc") + affectedvls = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvl") + affectedcps = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedcp") + vnfdmodule = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "vnfdmodule") + + req_data["vnfdmodule"] = vnfdmodule + + for affectedvnfc in affectedvnfcs: + req_data["affectedVnfc"].append({ + "vnfcInstanceId": ignorcase_get(affectedvnfc, "vnfcInstanceId"), + "vduId": ignorcase_get(affectedvnfc, "vduId"), + "changeType": ignorcase_get(affectedvnfc, "changeType"), + "vimId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "vimId"), + "vmId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceId"), + "vmName": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceName") + }) + + for affectedvl in affectedvls: + req_data["affectedVl"].append({ + "vlInstanceId": ignorcase_get(affectedvl, "virtualLinkInstanceId"), + "changeType": ignorcase_get(affectedvl, "changeType"), + "vimId": ignorcase_get(ignorcase_get(affectedvl, "networkResource"), "vimId"), + "vldId": ignorcase_get(affectedvl, "virtuallinkdescid"), + "networkResource": { + "resourceType": "network", + "resourceId": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourceid"), + "resourceName": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourcename") + } + }) + + for affectedcp in affectedcps: + req_data["affectedCp"].append(affectedcp) + + vnfmid = ignorcase_get(req_data, 'vnfmId') + vnfInstanceId = ignorcase_get(req_data, 'vnfinstanceid') + notify_url = 'api/nslcm/v1/ns/%s/vnfs/%s/Notify' % (vnfmid, vnfInstanceId) + logger.debug("notify_url = %s", notify_url) + logger.debug("req_data = %s", req_data) + ret = req_by_msb(notify_url, "POST", content=json.JSONEncoder().encode(req_data)) + + logger.debug("[%s]data = %s", fun_name(), ret) + if ret[0] != 0: + raise Exception(ret[1]) + + return Response(data=None, status=status.HTTP_200_OK) + except Exception as e: + logger.error("Error occurred in LCM notification,error: %s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'Notify expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + +class Scale(APIView): + @swagger_auto_schema( + request_body=ScaleReqSerializer(), + responses={ + status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(), + status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error" + } + ) + def post(self, request, vnfmid, vnfInstanceId): + logger.debug("====scale_vnf===") + try: + logger.debug("request.data = %s", request.data) + logger.debug("requested_url = %s", request.get_full_path()) + scaleReqSerializer = ScaleReqSerializer(data=request.data) + if not scaleReqSerializer.is_valid(): + raise Exception(scaleReqSerializer.errors) + + ret = get_vnfminfo_from_nslcm(vnfmid) + if ret[0] != 0: + raise Exception(ret[1]) + + vnfm_info = json.JSONDecoder().decode(ret[1]) + scale_type = ignorcase_get(scaleReqSerializer.data, "type") + aspect_id = ignorcase_get(scaleReqSerializer.data, "aspectId") + number_of_steps = ignorcase_get(scaleReqSerializer.data, "numberOfSteps") + data = { + 'vnfmid': vnfmid, + 'nfvoid': 1, + 'scaletype': '0' if scale_type == 'SCALE_OUT' else '1', + 'vmlist': [{ + 'VMNumber': number_of_steps, + 'VMFlavor': aspect_id + }], + 'extension': '' + } + + logger.debug("data = %s", data) + ret = restcall.call_req( + base_url=ignorcase_get(vnfm_info, "url"), + user=ignorcase_get(vnfm_info, "userName"), + passwd=ignorcase_get(vnfm_info, "password"), + auth_type=restcall.rest_no_auth, + resource='/v1/vnfs/{vnfInstanceID}/scale'.format(vnfInstanceID=vnfInstanceId), + method='put', # POST + content=json.JSONEncoder().encode(data)) + logger.debug("ret=%s", ret) + if ret[0] != 0: + raise Exception('scale error') + + scaleRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1])) + if not scaleRespSerializer.is_valid(): + raise Exception(scaleRespSerializer.errors) + + logger.debug("scaleRespSerializer.data=%s", scaleRespSerializer.data) + return Response(data=scaleRespSerializer.data, status=status.HTTP_202_ACCEPTED) + except Exception as e: + logger.error("Error occurred when scaling VNF,error:%s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'Scale expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) + + +class Heal(APIView): + @swagger_auto_schema( + request_body=HealReqSerializer(), + responses={ + status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(), + status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error" + } + ) + def post(self, request, vnfmid, vnfInstanceId): + logger.debug("====heal_vnf===") + try: + logger.debug("request.data = %s", request.data) + logger.debug("requested_url = %s", request.get_full_path()) + healReqSerializer = HealReqSerializer(data=request.data) + if not healReqSerializer.is_valid(): + raise Exception(healReqSerializer.errors) + + logger.debug("healReqSerializer.data = %s", healReqSerializer.data) + logger.debug("vnfmid = %s", vnfmid) + ret = get_vnfminfo_from_nslcm(vnfmid) + if ret[0] != 0: + raise Exception(ret[1]) + + vnfm_info = json.JSONDecoder().decode(ret[1]) + req_data = { + "action": ignorcase_get(healReqSerializer.data, 'action'), + "lifecycleoperation": "operate", + "isgrace": "force", + "affectedvm": [], + } + affectedvm = ignorcase_get(healReqSerializer.data, 'affectedvm') + if isinstance(affectedvm, list): + req_data['affectedvm'] = affectedvm + else: + req_data['affectedvm'].append(affectedvm) + + logger.debug("req_data = %s", req_data) + ret = restcall.call_req( + base_url=ignorcase_get(vnfm_info, "url"), + user=ignorcase_get(vnfm_info, "userName"), + passwd=ignorcase_get(vnfm_info, "password"), + auth_type=restcall.rest_no_auth, + resource='/api/v1/nf_m_i/nfs/{vnfInstanceID}/vms/operation'.format(vnfInstanceID=vnfInstanceId), + method='post', + content=json.JSONEncoder().encode(req_data)) + logger.debug("ret=%s", ret) + if ret[0] != 0: + raise Exception('heal error') + + healRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1])) + if not healRespSerializer.is_valid(): + raise Exception(healRespSerializer.errors) + + logger.debug("healRespSerializer.data=%s", healRespSerializer.data) + return Response(data=healRespSerializer.data, status=status.HTTP_202_ACCEPTED) + except Exception as e: + logger.error("Error occurred when healing VNF,error:%s", e.message) + logger.error(traceback.format_exc()) + return Response(data={'error': 'Heal expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR) def get_vdus(nf_model, aspect_id): @@ -570,6 +633,66 @@ def get_vdus(nf_model, aspect_id): return members -@api_view(http_method_names=['GET']) -def samples(request, *args, **kwargs): - return Response(data={"status": "ok"}) +class SampleList(APIView): + @swagger_auto_schema( + responses={ + status.HTTP_200_OK: 'Successfully'}) + def get(self, request): + logger.debug("get") + return Response({"status": "active"}) + + +class Subscribe(APIView): + def get(self, request): + logger.debug("====Subscribe get====") + resp_data = { + "subscriptions": [{ + "subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657", + "filter": [{ + "vendor": "ZTE", + "type": "vCPE", + }], + "notificationuri": " https://127.0.0.1:80/v2/vnfm/vnfds/notification", + }] + } + return Response(data=resp_data, status=status.HTTP_200_OK) + + def post(self, request): + logger.debug("====Subscribe post====") + resp_data = {"subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657"} + return Response(data=resp_data, status=status.HTTP_201_CREATED) + + +class SubscribeDetail(APIView): + def delete(self, request, subscribeId): + logger.debug("====SubscribeDetail delete %s====", subscribeId) + return Response(status=status.HTTP_204_NO_CONTENT) + + +class VnfPkgs(APIView): + def get(self, request): + logger.debug("====VnfPkgs get====") + resp_data = { + "data": [{ + "packageid": "924fc980-4530-11e9-ae68-acc860114657", + "vendor": "ZTE", + "type": "vCPE", + "vnfdfile": "MRP6600_FS_SRIOV_4NIC_200W.zip", + "imagefiles": ["MRP6600_FS_SRIOV_MRPISU_IMGV500R008C20SPC030T.tar"], + "swfiles": ["MRP6600_SRV_V500R008C20SPC030T.tar"], + "description": "This is a service for vCPE.", + }] + } + return Response(data=resp_data, status=status.HTTP_200_OK) + + +class VnfPkg(APIView): + def get(self, request, packageId, fileName): + logger.debug("====VnfPkg get====%s, %s", packageId, fileName) + file_range = request.META.get('RANGE') + logger.debug('file_range: %s' % file_range) + # TODO: get filepath + local_file_path = fileName + start, end = parse_file_range(local_file_path, file_range) + file_iterator = read(local_file_path, start, end) + return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)