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