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