zte/vmanager/driver/interfaces/views.py

   1 # Copyright 2016-2017 ZTE Corporation.
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 import inspect
  16 import json
  17 import logging
  18 import os
  19 import traceback
  20
  21 from drf_yasg import openapi
  22 from drf_yasg.utils import swagger_auto_schema
  23 from rest_framework import status
  24 from rest_framework.response import Response
  25 from rest_framework.views import APIView
  26 from django.http import StreamingHttpResponse
  27
  28 from driver.interfaces.serializers import HealReqSerializer, InstScaleHealRespSerializer, ScaleReqSerializer, \
  29     NotifyReqSerializer, GrantRespSerializer, GrantReqSerializer, JobQueryRespSerializer, TerminateVnfRequestSerializer, \
  30     InstantiateVnfRequestSerializer, QueryVnfResponseSerializer
  31 from driver.pub.config.config import VNF_FTP
  32 from driver.pub.utils import restcall
  33 from driver.pub.utils.restcall import req_by_msb
  34
  35 CHUNK_SIZE = 1024 * 8
  36
  37 logger = logging.getLogger(__name__)
  38
  39
  40 def load_json_file(file_name):
  41     json_file = os.path.join(os.path.dirname(__file__), "data/" + file_name)
  42     f = open(json_file)
  43     json_data = json.JSONDecoder().decode(f.read())
  44     f.close()
  45     return json_data
  46
  47
  48 def read(file_path, start, end):
  49     fp = open(file_path, 'rb')
  50     fp.seek(start)
  51     pos = start
  52     while pos + CHUNK_SIZE < end:
  53         yield fp.read(CHUNK_SIZE)
  54         pos = fp.tell()
  55     yield fp.read(end - pos)
  56
  57
  58 def parse_file_range(file_path, file_range):
  59     start, end = 0, os.path.getsize(file_path)
  60     if file_range:
  61         [start, end] = file_range.split('-')
  62         start, end = start.strip(), end.strip()
  63         start, end = int(start), int(end)
  64     return start, end
  65
  66
  67 def fun_name():
  68     return "=================%s==================" % inspect.stack()[1][3]
  69
  70
  71 def ignorcase_get(args, key):
  72     if not key:
  73         return ""
  74     if not args:
  75         return ""
  76     if key in args:
  77         return args[key]
  78     for old_key in args:
  79         if old_key.upper() == key.upper():
  80             return args[old_key]
  81     return ""
  82
  83
  84 # Query vnfm_info from nslcm
  85 def get_vnfminfo_from_nslcm(vnfmid):
  86     ret = req_by_msb("api/nslcm/v1/vnfms/%s" % vnfmid, "GET")
  87     return ret
  88
  89
  90 # Query vnfd_info from nslcm
  91 def vnfd_get(vnfpackageid):
  92     ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % vnfpackageid, "GET")
  93     return ret
  94
  95
  96 # Query vnfpackage_info from nslcm
  97 def vnfpackage_get(csarid):
  98     ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % csarid, "GET")
  99     return ret
 100
 101
 102 class InstantiateVnf(APIView):
 103     @swagger_auto_schema(
 104         request_body=InstantiateVnfRequestSerializer(),
 105         responses={
 106             status.HTTP_200_OK: InstScaleHealRespSerializer(),
 107             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 108         }
 109     )
 110     def post(self, request, vnfmid):
 111         try:
 112             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 113             instantiateVnfRequestSerializer = InstantiateVnfRequestSerializer(data=request.data)
 114             if not instantiateVnfRequestSerializer.is_valid():
 115                 raise Exception(instantiateVnfRequestSerializer.errors)
 116
 117             ret = get_vnfminfo_from_nslcm(vnfmid)
 118             if ret[0] != 0:
 119                 raise Exception(ret[1])
 120
 121             vnfm_info = json.JSONDecoder().decode(ret[1])
 122             logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 123             vnf_package_id = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfPackageId")
 124             ret = vnfd_get(vnf_package_id)
 125             if ret[0] != 0:
 126                 raise Exception(ret[1])
 127
 128             vnfd_info = json.JSONDecoder().decode(ret[1])
 129             logger.debug("[%s] vnfd_info=%s", fun_name(), vnfd_info)
 130             csar_id = ignorcase_get(vnfd_info, "csarId")
 131             ret = vnfpackage_get(csar_id)
 132             if ret[0] != 0:
 133                 raise Exception(ret[1])
 134
 135             vnf_package_info = json.JSONDecoder().decode(ret[1])
 136             packageInfo = ignorcase_get(vnf_package_info, "packageInfo")
 137             logger.debug("[%s] packageInfo=%s", fun_name(), packageInfo)
 138             data = {
 139                 "NFVOID": 1,
 140                 "VNFMID": vnfmid,
 141                 "extension": {},
 142             }
 143             vnfdModel = json.loads(ignorcase_get(packageInfo, "vnfdModel"))
 144             metadata = ignorcase_get(vnfdModel, "metadata")
 145             vnfd_name = ignorcase_get(metadata, "name")
 146             # TODO  convert sdc vnf package to vnf vender package
 147             inputs = []
 148             if "SPGW" in vnfd_name.upper():
 149                 data["VNFD"] = VNF_FTP + "SPGW"
 150                 inputs = load_json_file("SPGW" + "_inputs.json")
 151             elif "MME" in vnfd_name.upper():
 152                 data["VNFD"] = VNF_FTP + "MME"
 153                 inputs = load_json_file("MME" + "_inputs.json")
 154             else:
 155                 data["VNFD"] = ignorcase_get(packageInfo, "downloadUri")
 156
 157             data["VNFURL"] = data["VNFD"]
 158
 159             additionalParam = ignorcase_get(instantiateVnfRequestSerializer.data, "additionalParam")
 160             for name, value in ignorcase_get(additionalParam, "inputs").items():
 161                 inputs.append({"name": name, "value": value})
 162
 163             data["extension"]["inputs"] = json.dumps(inputs)
 164             data["extension"]["extVirtualLinks"] = ignorcase_get(additionalParam, "extVirtualLinks")
 165             data["extension"]["vnfinstancename"] = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfInstanceName")
 166             data["extension"]["vnfid"] = data["VNFD"]
 167             data["extension"]["multivim"] = 0
 168             logger.debug("[%s] call_req data=%s", fun_name(), data)
 169
 170             ret = restcall.call_req(
 171                 base_url=ignorcase_get(vnfm_info, "url"),
 172                 user=ignorcase_get(vnfm_info, "userName"),
 173                 passwd=ignorcase_get(vnfm_info, "password"),
 174                 auth_type=restcall.rest_no_auth,
 175                 resource="v1/vnfs",
 176                 method='post',
 177                 content=json.JSONEncoder().encode(data))
 178
 179             logger.debug("[%s] call_req ret=%s", fun_name(), ret)
 180             if ret[0] != 0:
 181                 raise Exception(ret[1])
 182
 183             resp = json.JSONDecoder().decode(ret[1])
 184             resp_data = {
 185                 "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
 186                 "jobId": ignorcase_get(resp, "JobId")
 187             }
 188             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 189             instRespSerializer = InstScaleHealRespSerializer(data=resp_data)
 190             if not instRespSerializer.is_valid():
 191                 raise Exception(instRespSerializer.errors)
 192
 193             logger.debug("[%s] instRespSerializer.data=%s", fun_name(), instRespSerializer.data)
 194             return Response(data=instRespSerializer.data, status=status.HTTP_200_OK)
 195         except Exception as e:
 196             logger.error("Error occurred when instantiating VNF,error:%s", e.message)
 197             logger.error(traceback.format_exc())
 198             return Response(data={'error': 'InstantiateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 199
 200
 201 class TerminateVnf(APIView):
 202     @swagger_auto_schema(
 203         request_body=TerminateVnfRequestSerializer(),
 204         responses={
 205             status.HTTP_200_OK: InstScaleHealRespSerializer(),
 206             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 207         }
 208     )
 209     def post(self, request, vnfmid, vnfInstanceId):
 210         try:
 211             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 212             terminate_vnf_request_serializer = TerminateVnfRequestSerializer(data=request.data)
 213             if not terminate_vnf_request_serializer.is_valid():
 214                 raise Exception(terminate_vnf_request_serializer.errors)
 215
 216             ret = get_vnfminfo_from_nslcm(vnfmid)
 217             if ret[0] != 0:
 218                 raise Exception(ret[1])
 219
 220             vnfm_info = json.JSONDecoder().decode(ret[1])
 221             logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 222             ret = restcall.call_req(
 223                 base_url=ignorcase_get(vnfm_info, "url"),
 224                 user=ignorcase_get(vnfm_info, "userName"),
 225                 passwd=ignorcase_get(vnfm_info, "password"),
 226                 auth_type=restcall.rest_no_auth,
 227                 resource="v1/vnfs/%s" % vnfInstanceId,
 228                 method='delete',
 229                 content=json.JSONEncoder().encode(terminate_vnf_request_serializer.data))
 230             if ret[0] != 0:
 231                 raise Exception(ret[1])
 232
 233             resp = json.JSONDecoder().decode(ret[1])
 234             resp_data = {
 235                 "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
 236                 "jobId": ignorcase_get(resp, "JobId")
 237             }
 238             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 239             terminateRespSerializer = InstScaleHealRespSerializer(data=resp_data)
 240             if not terminateRespSerializer.is_valid():
 241                 raise Exception(terminateRespSerializer.errors)
 242             return Response(data=terminateRespSerializer.data, status=status.HTTP_200_OK)
 243         except Exception as e:
 244             logger.error("Error occurred when terminating VNF,error: %s", e.message)
 245             logger.error(traceback.format_exc())
 246             return Response(data={'error': 'TerminateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 247
 248
 249 class QueryVnf(APIView):
 250     @swagger_auto_schema(
 251         responses={
 252             status.HTTP_200_OK: QueryVnfResponseSerializer(),
 253             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 254         }
 255     )
 256     def get(self, request, vnfmid, vnfInstanceId):
 257         try:
 258             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 259             ret = get_vnfminfo_from_nslcm(vnfmid)
 260             if ret[0] != 0:
 261                 raise Exception(ret[1])
 262
 263             vnfm_info = json.JSONDecoder().decode(ret[1])
 264             logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 265             ret = restcall.call_req(
 266                 base_url=ignorcase_get(vnfm_info, "url"),
 267                 user=ignorcase_get(vnfm_info, "userName"),
 268                 passwd=ignorcase_get(vnfm_info, "password"),
 269                 auth_type=restcall.rest_no_auth,
 270                 resource="v1/vnfs/%s" % vnfInstanceId,
 271                 method='get',
 272                 content=json.JSONEncoder().encode({}))
 273             if ret[0] != 0:
 274                 raise Exception(ret[1])
 275
 276             resp = json.JSONDecoder().decode(ret[1])
 277             vnf_status = ignorcase_get(resp, "vnfinstancestatus")
 278             resp_data = {"vnfInfo": {"vnfStatus": vnf_status}}
 279             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 280             queryVnfResponseSerializer = QueryVnfResponseSerializer(data=resp_data)
 281             if not queryVnfResponseSerializer.is_valid():
 282                 raise Exception(queryVnfResponseSerializer.errors)
 283             return Response(data=queryVnfResponseSerializer.data, status=status.HTTP_200_OK)
 284         except Exception as e:
 285             logger.error("Error occurred when querying VNF information,error:%s", e.message)
 286             logger.error(traceback.format_exc())
 287             return Response(data={'error': 'QueryVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 288
 289
 290 class JobView(APIView):
 291     @swagger_auto_schema(
 292         manual_parameters=[
 293             openapi.Parameter('responseId',
 294                               openapi.IN_QUERY,
 295                               "responseId",
 296                               type=openapi.TYPE_INTEGER
 297                               ),
 298         ],
 299         responses={
 300             status.HTTP_200_OK: JobQueryRespSerializer(),
 301             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 302         }
 303     )
 304     def get(self, request, vnfmid, jobid):
 305         try:
 306             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 307             ret = get_vnfminfo_from_nslcm(vnfmid)
 308             if ret[0] != 0:
 309                 raise Exception(ret[1])
 310
 311             vnfm_info = json.JSONDecoder().decode(ret[1])
 312             logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 313             operation_status_url = '/v1/jobs/{jobId}?NFVOID={nfvoId}&VNFMID={vnfmId}&ResponseID={responseId}'
 314             responseId = ignorcase_get(request.GET, 'responseId')
 315             query_url = operation_status_url.format(jobId=jobid, nfvoId=1, vnfmId=vnfmid, responseId=responseId)
 316             ret = restcall.call_req(
 317                 base_url=ignorcase_get(vnfm_info, 'url'),
 318                 user=ignorcase_get(vnfm_info, 'userName'),
 319                 passwd=ignorcase_get(vnfm_info, 'password'),
 320                 auth_type=restcall.rest_no_auth,
 321                 resource=query_url,
 322                 method='get',
 323                 content={})
 324
 325             if ret[0] != 0:
 326                 raise Exception(ret[1])
 327
 328             resp_data = json.JSONDecoder().decode(ret[1])
 329             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 330             jobQueryRespSerializer = JobQueryRespSerializer(data=resp_data)
 331             if not jobQueryRespSerializer.is_valid():
 332                 raise Exception(jobQueryRespSerializer.errors)
 333
 334             return Response(data=jobQueryRespSerializer.data, status=status.HTTP_200_OK)
 335         except Exception as e:
 336             logger.error("Error occurred when getting operation status information,error:%s", e.message)
 337             logger.error(traceback.format_exc())
 338             return Response(data={'error': 'QueryJob expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 339
 340
 341 class GrantVnf(APIView):
 342     @swagger_auto_schema(
 343         request_body=GrantReqSerializer(),
 344         responses={
 345             status.HTTP_201_CREATED: GrantRespSerializer(),
 346             status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
 347         }
 348     )
 349     def put(self, request):
 350         logger.debug("=====GrantVnf=====")
 351         try:
 352             logger.debug("request.data = %s", request.data)
 353             grantReqSerializer = GrantReqSerializer(data=request.data)
 354             if not grantReqSerializer.is_valid():
 355                 raise Exception(grantReqSerializer.errors)
 356
 357             logger.debug("grantReqSerializer.data = %s", grantReqSerializer.data)
 358             req_data = {
 359                 "vnfInstanceId": ignorcase_get(grantReqSerializer.data, "vnfistanceid"),
 360                 "vnfDescriptorId": "",
 361                 "addresource": [],
 362                 "additionalparam": {
 363                     "vnfmid": ignorcase_get(grantReqSerializer.data, "vnfmid"),
 364                     "vimid": ignorcase_get(grantReqSerializer.data, "vimid"),
 365                     "tenant": ignorcase_get(grantReqSerializer.data, "tenant")
 366                 }
 367             }
 368             if ignorcase_get(grantReqSerializer.data, "operationright") == 0:
 369                 req_data["lifecycleOperation"] = "Instantiate"
 370                 for vm in ignorcase_get(grantReqSerializer.data, "vmlist"):
 371                     for i in range(int(ignorcase_get(vm, "VMNumber"))):
 372                         req_data["addresource"].append(
 373                             {
 374                                 "type": "vdu",
 375                                 "resourceDefinitionId": i,
 376                                 "vdu": ignorcase_get(vm, "VMFlavor"),
 377                                 "vimid": ignorcase_get(vm, "vimid"),
 378                                 "tenant": ignorcase_get(vm, "tenant")})
 379
 380             logger.debug("req_data=%s", req_data)
 381             ret = req_by_msb('api/nslcm/v1/ns/grantvnf', "POST", content=json.JSONEncoder().encode(req_data))
 382             logger.info("ret = %s", ret)
 383             if ret[0] != 0:
 384                 raise Exception(ret[1])
 385
 386             resp = json.JSONDecoder().decode(ret[1])
 387             resp_data = {
 388                 'vimid': ignorcase_get(resp['vim'], 'vimid'),
 389                 'tenant': ignorcase_get(ignorcase_get(resp['vim'], 'accessinfo'), 'tenant')
 390             }
 391             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 392             grantRespSerializer = GrantRespSerializer(data=resp_data)
 393             if not grantRespSerializer.is_valid():
 394                 raise Exception(grantRespSerializer.errors)
 395
 396             logger.debug("grantRespSerializer.data=%s", grantRespSerializer.data)
 397             return Response(data=grantRespSerializer.data, status=status.HTTP_201_CREATED)
 398         except Exception as e:
 399             logger.error("Error occurred in Grant VNF, error: %s", e.message)
 400             logger.error(traceback.format_exc())
 401             return Response(data={'error': 'Grant expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 402
 403
 404 class Notify(APIView):
 405     @swagger_auto_schema(
 406         request_body=NotifyReqSerializer(),
 407         responses={
 408             status.HTTP_200_OK: 'Successfully',
 409             status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
 410         }
 411     )
 412     def post(self, request):
 413         try:
 414             logger.debug("[%s]request.data = %s", fun_name(), request.data)
 415             notifyReqSerializer = NotifyReqSerializer(data=request.data)
 416             if not notifyReqSerializer.is_valid():
 417                 raise Exception(notifyReqSerializer.errors)
 418
 419             logger.debug("[%s]notifyReqSerializer.data = %s", fun_name(), notifyReqSerializer.data)
 420             req_data = {
 421                 "status": "result",
 422                 "vnfInstanceId": ignorcase_get(notifyReqSerializer.data, "vnfinstanceid"),
 423                 "vnfmId": ignorcase_get(notifyReqSerializer.data, "vnfmid"),
 424                 "vimId": ignorcase_get(notifyReqSerializer.data, "vimid"),
 425                 "operation": ignorcase_get(notifyReqSerializer.data, "EventType"),
 426                 "jobId": "notMust",
 427                 "affectedVl": [],
 428                 "affectedCp": [],
 429                 "affectedVirtualStorage": [],
 430                 "affectedVnfc": [],
 431             }
 432
 433             extension = ignorcase_get(notifyReqSerializer.data, "extension")
 434             openo_notification = ignorcase_get(extension, "openo_notification")
 435             if openo_notification:
 436                 affectedvnfcs = ignorcase_get(openo_notification, "affectedVnfc")
 437                 affectedvls = ignorcase_get(openo_notification, "affectedvirtuallink")
 438                 affectedcps = ignorcase_get(openo_notification, "affectedCp")
 439                 vnfdmodule = ignorcase_get(openo_notification, "vnfdmodule")
 440             else:
 441                 affectedvnfcs = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvnfc")
 442                 affectedvls = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvl")
 443                 affectedcps = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedcp")
 444                 vnfdmodule = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "vnfdmodule")
 445
 446             req_data["vnfdmodule"] = vnfdmodule
 447
 448             for affectedvnfc in affectedvnfcs:
 449                 req_data["affectedVnfc"].append({
 450                     "vnfcInstanceId": ignorcase_get(affectedvnfc, "vnfcInstanceId"),
 451                     "vduId": ignorcase_get(affectedvnfc, "vduId"),
 452                     "changeType": ignorcase_get(affectedvnfc, "changeType"),
 453                     "vimId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "vimId"),
 454                     "vmId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceId"),
 455                     "vmName": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceName")
 456                 })
 457
 458             for affectedvl in affectedvls:
 459                 req_data["affectedVl"].append({
 460                     "vlInstanceId": ignorcase_get(affectedvl, "virtualLinkInstanceId"),
 461                     "changeType": ignorcase_get(affectedvl, "changeType"),
 462                     "vimId": ignorcase_get(ignorcase_get(affectedvl, "networkResource"), "vimId"),
 463                     "vldId": ignorcase_get(affectedvl, "virtuallinkdescid"),
 464                     "networkResource": {
 465                         "resourceType": "network",
 466                         "resourceId": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourceid"),
 467                         "resourceName": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourcename")
 468                     }
 469                 })
 470
 471             for affectedcp in affectedcps:
 472                 req_data["affectedCp"].append(affectedcp)
 473
 474             vnfmid = ignorcase_get(req_data, 'vnfmId')
 475             vnfInstanceId = ignorcase_get(req_data, 'vnfinstanceid')
 476             notify_url = 'api/nslcm/v1/ns/%s/vnfs/%s/Notify' % (vnfmid, vnfInstanceId)
 477             logger.debug("notify_url = %s", notify_url)
 478             logger.debug("req_data = %s", req_data)
 479             ret = req_by_msb(notify_url, "POST", content=json.JSONEncoder().encode(req_data))
 480
 481             logger.debug("[%s]data = %s", fun_name(), ret)
 482             if ret[0] != 0:
 483                 raise Exception(ret[1])
 484
 485             return Response(data=None, status=status.HTTP_200_OK)
 486         except Exception as e:
 487             logger.error("Error occurred in LCM notification,error: %s", e.message)
 488             logger.error(traceback.format_exc())
 489             return Response(data={'error': 'Notify expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 490
 491
 492 class Scale(APIView):
 493     @swagger_auto_schema(
 494         request_body=ScaleReqSerializer(),
 495         responses={
 496             status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
 497             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 498         }
 499     )
 500     def post(self, request, vnfmid, vnfInstanceId):
 501         logger.debug("====scale_vnf===")
 502         try:
 503             logger.debug("request.data = %s", request.data)
 504             logger.debug("requested_url = %s", request.get_full_path())
 505             scaleReqSerializer = ScaleReqSerializer(data=request.data)
 506             if not scaleReqSerializer.is_valid():
 507                 raise Exception(scaleReqSerializer.errors)
 508
 509             ret = get_vnfminfo_from_nslcm(vnfmid)
 510             if ret[0] != 0:
 511                 raise Exception(ret[1])
 512
 513             vnfm_info = json.JSONDecoder().decode(ret[1])
 514             scale_type = ignorcase_get(scaleReqSerializer.data, "type")
 515             aspect_id = ignorcase_get(scaleReqSerializer.data, "aspectId")
 516             number_of_steps = ignorcase_get(scaleReqSerializer.data, "numberOfSteps")
 517             data = {
 518                 'vnfmid': vnfmid,
 519                 'nfvoid': 1,
 520                 'scaletype': '0' if scale_type == 'SCALE_OUT' else '1',
 521                 'vmlist': [{
 522                     'VMNumber': number_of_steps,
 523                     'VMFlavor': aspect_id
 524                 }],
 525                 'extension': ''
 526             }
 527
 528             logger.debug("data = %s", data)
 529             ret = restcall.call_req(
 530                 base_url=ignorcase_get(vnfm_info, "url"),
 531                 user=ignorcase_get(vnfm_info, "userName"),
 532                 passwd=ignorcase_get(vnfm_info, "password"),
 533                 auth_type=restcall.rest_no_auth,
 534                 resource='/v1/vnfs/{vnfInstanceID}/scale'.format(vnfInstanceID=vnfInstanceId),
 535                 method='put',  # POST
 536                 content=json.JSONEncoder().encode(data))
 537             logger.debug("ret=%s", ret)
 538             if ret[0] != 0:
 539                 raise Exception('scale error')
 540
 541             scaleRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
 542             if not scaleRespSerializer.is_valid():
 543                 raise Exception(scaleRespSerializer.errors)
 544
 545             logger.debug("scaleRespSerializer.data=%s", scaleRespSerializer.data)
 546             return Response(data=scaleRespSerializer.data, status=status.HTTP_202_ACCEPTED)
 547         except Exception as e:
 548             logger.error("Error occurred when scaling VNF,error:%s", e.message)
 549             logger.error(traceback.format_exc())
 550             return Response(data={'error': 'Scale expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 551
 552
 553 class Heal(APIView):
 554     @swagger_auto_schema(
 555         request_body=HealReqSerializer(),
 556         responses={
 557             status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
 558             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 559         }
 560     )
 561     def post(self, request, vnfmid, vnfInstanceId):
 562         logger.debug("====heal_vnf===")
 563         try:
 564             logger.debug("request.data = %s", request.data)
 565             logger.debug("requested_url = %s", request.get_full_path())
 566             healReqSerializer = HealReqSerializer(data=request.data)
 567             if not healReqSerializer.is_valid():
 568                 raise Exception(healReqSerializer.errors)
 569
 570             logger.debug("healReqSerializer.data = %s", healReqSerializer.data)
 571             logger.debug("vnfmid = %s", vnfmid)
 572             ret = get_vnfminfo_from_nslcm(vnfmid)
 573             if ret[0] != 0:
 574                 raise Exception(ret[1])
 575
 576             vnfm_info = json.JSONDecoder().decode(ret[1])
 577             req_data = {
 578                 "action": ignorcase_get(healReqSerializer.data, 'action'),
 579                 "lifecycleoperation": "operate",
 580                 "isgrace": "force",
 581                 "affectedvm": [],
 582             }
 583             affectedvm = ignorcase_get(healReqSerializer.data, 'affectedvm')
 584             if isinstance(affectedvm, list):
 585                 req_data['affectedvm'] = affectedvm
 586             else:
 587                 req_data['affectedvm'].append(affectedvm)
 588
 589             logger.debug("req_data = %s", req_data)
 590             ret = restcall.call_req(
 591                 base_url=ignorcase_get(vnfm_info, "url"),
 592                 user=ignorcase_get(vnfm_info, "userName"),
 593                 passwd=ignorcase_get(vnfm_info, "password"),
 594                 auth_type=restcall.rest_no_auth,
 595                 resource='/api/v1/nf_m_i/nfs/{vnfInstanceID}/vms/operation'.format(vnfInstanceID=vnfInstanceId),
 596                 method='post',
 597                 content=json.JSONEncoder().encode(req_data))
 598             logger.debug("ret=%s", ret)
 599             if ret[0] != 0:
 600                 raise Exception('heal error')
 601
 602             healRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
 603             if not healRespSerializer.is_valid():
 604                 raise Exception(healRespSerializer.errors)
 605
 606             logger.debug("healRespSerializer.data=%s", healRespSerializer.data)
 607             return Response(data=healRespSerializer.data, status=status.HTTP_202_ACCEPTED)
 608         except Exception as e:
 609             logger.error("Error occurred when healing VNF,error:%s", e.message)
 610             logger.error(traceback.format_exc())
 611             return Response(data={'error': 'Heal expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 612
 613
 614 def get_vdus(nf_model, aspect_id):
 615     associated_group = ''
 616     members = []
 617     vnf_flavours = nf_model['vnf_flavours']
 618     for vnf_flaour in vnf_flavours:
 619         scaling_aspects = vnf_flaour['scaling_aspects']
 620         for aspect in scaling_aspects:
 621             if aspect_id == aspect['id']:
 622                 associated_group = aspect['associated_group']
 623                 break
 624     if not associated_group:
 625         logger.error('Cannot find the corresponding element group')
 626         raise Exception('Cannot find the corresponding element group')
 627     for element_group in nf_model['element_groups']:
 628         if element_group['group_id'] == associated_group:
 629             members = element_group['members']
 630     if not members:
 631         logger.error('Cannot find the corresponding members')
 632         raise Exception('Cannot find the corresponding members')
 633     return members
 634
 635
 636 class SampleList(APIView):
 637     @swagger_auto_schema(
 638         responses={
 639             status.HTTP_200_OK: 'Successfully'})
 640     def get(self, request):
 641         logger.debug("get")
 642         return Response({"status": "active"})
 643
 644
 645 class Subscribe(APIView):
 646     def get(self, request):
 647         logger.debug("====Subscribe get====")
 648         resp_data = {
 649             "subscriptions": [{
 650                 "subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657",
 651                 "filter": [{
 652                     "vendor": "ZTE",
 653                     "type": "vCPE",
 654                 }],
 655                 "notificationuri": " https://127.0.0.1:80/v2/vnfm/vnfds/notification",
 656             }]
 657         }
 658         return Response(data=resp_data, status=status.HTTP_200_OK)
 659
 660     def post(self, request):
 661         logger.debug("====Subscribe post====")
 662         resp_data = {"subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657"}
 663         return Response(data=resp_data, status=status.HTTP_201_CREATED)
 664
 665
 666 class SubscribeDetail(APIView):
 667     def delete(self, request, subscribeId):
 668         logger.debug("====SubscribeDetail delete %s====", subscribeId)
 669         return Response(status=status.HTTP_204_NO_CONTENT)
 670
 671
 672 class VnfPkgs(APIView):
 673     def get(self, request):
 674         logger.debug("====VnfPkgs get====")
 675         resp_data = {
 676             "data": [{
 677                 "packageid": "924fc980-4530-11e9-ae68-acc860114657",
 678                 "vendor": "ZTE",
 679                 "type": "vCPE",
 680                 "vnfdfile": "MRP6600_FS_SRIOV_4NIC_200W.zip",
 681                 "imagefiles": ["MRP6600_FS_SRIOV_MRPISU_IMGV500R008C20SPC030T.tar"],
 682                 "swfiles": ["MRP6600_SRV_V500R008C20SPC030T.tar"],
 683                 "description": "This is a service for vCPE.",
 684             }]
 685         }
 686         return Response(data=resp_data, status=status.HTTP_200_OK)
 687
 688
 689 class VnfPkg(APIView):
 690     def get(self, request, packageId, fileName):
 691         logger.debug("====VnfPkg get====%s, %s", packageId, fileName)
 692         file_range = request.META.get('RANGE')
 693         logger.debug('file_range: %s' % file_range)
 694         # TODO: get filepath
 695         local_file_path = fileName
 696         start, end = parse_file_range(local_file_path, file_range)
 697         file_iterator = read(local_file_path, start, end)
 698         return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)