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