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