zte/vmanager/driver/interfaces/views.py

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