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