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