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