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.response import Response
  25 from rest_framework.views import APIView
  26 from django.http import StreamingHttpResponse
  27
  28 from driver.interfaces.serializers import HealReqSerializer, InstScaleHealRespSerializer, ScaleReqSerializer, \
  29     NotifyReqSerializer, GrantRespSerializer, GrantReqSerializer, JobQueryRespSerializer, TerminateVnfRequestSerializer, \
  30     InstantiateVnfRequestSerializer, QueryVnfResponseSerializer, SubscribesRespSerializer, \
  31     SubscribeReqSerializer, SubscribeRespSerializer
  32 from driver.pub.config.config import VNF_FTP
  33 from driver.pub.utils import restcall
  34 from driver.pub.utils.restcall import req_by_msb
  35
  36 CHUNK_SIZE = 1024 * 8
  37
  38 logger = logging.getLogger(__name__)
  39
  40
  41 def load_json_file(file_name):
  42     json_file = os.path.join(os.path.dirname(__file__), "data/" + file_name)
  43     f = open(json_file)
  44     json_data = json.JSONDecoder().decode(f.read())
  45     f.close()
  46     return json_data
  47
  48
  49 def read(file_path, start, end):
  50     fp = open(file_path, 'rb')
  51     fp.seek(start)
  52     pos = start
  53     while pos + CHUNK_SIZE < end:
  54         yield fp.read(CHUNK_SIZE)
  55         pos = fp.tell()
  56     yield fp.read(end - pos)
  57
  58
  59 def parse_file_range(file_path, file_range):
  60     start, end = 0, os.path.getsize(file_path)
  61     if file_range:
  62         [start, end] = file_range.split('-')
  63         start, end = start.strip(), end.strip()
  64         start, end = int(start), int(end)
  65     return start, end
  66
  67
  68 def fun_name():
  69     return "=================%s==================" % inspect.stack()[1][3]
  70
  71
  72 def ignorcase_get(args, key):
  73     if not key:
  74         return ""
  75     if not args:
  76         return ""
  77     if key in args:
  78         return args[key]
  79     for old_key in args:
  80         if old_key.upper() == key.upper():
  81             return args[old_key]
  82     return ""
  83
  84
  85 # Query vnfm_info from nslcm
  86 def get_vnfminfo_from_nslcm(vnfmid):
  87     ret = req_by_msb("api/nslcm/v1/vnfms/%s" % vnfmid, "GET")
  88     return ret
  89
  90
  91 # Query vnfd_info from nslcm
  92 def vnfd_get(vnfpackageid):
  93     ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % vnfpackageid, "GET")
  94     return ret
  95
  96
  97 # Query vnfpackage_info from nslcm
  98 def vnfpackage_get(csarid):
  99     ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % csarid, "GET")
 100     return ret
 101
 102
 103 class InstantiateVnf(APIView):
 104     @swagger_auto_schema(
 105         request_body=InstantiateVnfRequestSerializer(),
 106         responses={
 107             status.HTTP_200_OK: InstScaleHealRespSerializer(),
 108             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 109         }
 110     )
 111     def post(self, request, vnfmid):
 112         try:
 113             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 114             instantiateVnfRequestSerializer = InstantiateVnfRequestSerializer(data=request.data)
 115             if not instantiateVnfRequestSerializer.is_valid():
 116                 raise Exception(instantiateVnfRequestSerializer.errors)
 117
 118             ret = get_vnfminfo_from_nslcm(vnfmid)
 119             if ret[0] != 0:
 120                 raise Exception(ret[1])
 121
 122             vnfm_info = json.JSONDecoder().decode(ret[1])
 123             logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 124             vnf_package_id = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfPackageId")
 125             ret = vnfd_get(vnf_package_id)
 126             if ret[0] != 0:
 127                 raise Exception(ret[1])
 128
 129             vnfd_info = json.JSONDecoder().decode(ret[1])
 130             logger.debug("[%s] vnfd_info=%s", fun_name(), vnfd_info)
 131             csar_id = ignorcase_get(vnfd_info, "csarId")
 132             ret = vnfpackage_get(csar_id)
 133             if ret[0] != 0:
 134                 raise Exception(ret[1])
 135
 136             vnf_package_info = json.JSONDecoder().decode(ret[1])
 137             packageInfo = ignorcase_get(vnf_package_info, "packageInfo")
 138             logger.debug("[%s] packageInfo=%s", fun_name(), packageInfo)
 139             logger.debug("VNF_FTP=%s", VNF_FTP)
 140             data = {
 141                 "NFVOID": 1,
 142                 "VNFMID": vnfmid,
 143                 "vnfd_id": packageInfo.get("vnfdId"),
 144                 "deployflavorid": "TODO",
 145                 "extension": {},
 146                 "inputs": []
 147             }
 148
 149             additionalParam = ignorcase_get(instantiateVnfRequestSerializer.data, "additionalParam")
 150             for name, value in ignorcase_get(additionalParam, "inputs").items():
 151                 data["inputs"].append({"key_name": name, "value": value, "type": "TODO"})
 152
 153             logger.debug("[%s] call_req data=%s", fun_name(), data)
 154
 155             ret = restcall.call_req(
 156                 base_url=ignorcase_get(vnfm_info, "url"),
 157                 user=ignorcase_get(vnfm_info, "userName"),
 158                 passwd=ignorcase_get(vnfm_info, "password"),
 159                 auth_type=restcall.rest_no_auth,
 160                 resource="v1/vnfs",
 161                 method='post',
 162                 content=json.JSONEncoder().encode(data))
 163
 164             logger.debug("[%s] call_req ret=%s", fun_name(), ret)
 165             if ret[0] != 0:
 166                 raise Exception(ret[1])
 167
 168             resp = json.JSONDecoder().decode(ret[1])
 169             resp_data = {
 170                 "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
 171                 "jobId": ignorcase_get(resp, "JobId")
 172             }
 173             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 174             instRespSerializer = InstScaleHealRespSerializer(data=resp_data)
 175             if not instRespSerializer.is_valid():
 176                 raise Exception(instRespSerializer.errors)
 177
 178             logger.debug("[%s] instRespSerializer.data=%s", fun_name(), instRespSerializer.data)
 179             return Response(data=instRespSerializer.data, status=status.HTTP_200_OK)
 180         except Exception as e:
 181             logger.error("Error occurred when instantiating VNF,error:%s", e.message)
 182             logger.error(traceback.format_exc())
 183             return Response(data={'error': 'InstantiateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 184
 185
 186 class TerminateVnf(APIView):
 187     @swagger_auto_schema(
 188         request_body=TerminateVnfRequestSerializer(),
 189         responses={
 190             status.HTTP_200_OK: InstScaleHealRespSerializer(),
 191             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 192         }
 193     )
 194     def post(self, request, vnfmid, vnfInstanceId):
 195         try:
 196             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 197             logger.debug("vnfmid=%s, vnfInstanceId=%s", vnfmid, vnfInstanceId)
 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?NFVOID=1&VNFMID=%s" % (vnfInstanceId, vnfmid),
 214                 method='delete',
 215                 content='{}')
 216             if ret[0] != 0:
 217                 raise Exception(ret[1])
 218
 219             resp = json.JSONDecoder().decode(ret[1])
 220             resp_data = {
 221                 "vnfInstanceId": 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 class QueryVnf(APIView):
 236     @swagger_auto_schema(
 237         responses={
 238             status.HTTP_200_OK: QueryVnfResponseSerializer(),
 239             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 240         }
 241     )
 242     def get(self, request, vnfmid, vnfInstanceId):
 243         try:
 244             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 245             ret = get_vnfminfo_from_nslcm(vnfmid)
 246             if ret[0] != 0:
 247                 raise Exception(ret[1])
 248
 249             vnfm_info = json.JSONDecoder().decode(ret[1])
 250             logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 251             ret = restcall.call_req(
 252                 base_url=ignorcase_get(vnfm_info, "url"),
 253                 user=ignorcase_get(vnfm_info, "userName"),
 254                 passwd=ignorcase_get(vnfm_info, "password"),
 255                 auth_type=restcall.rest_no_auth,
 256                 resource="v1/vnfs/%s" % vnfInstanceId,
 257                 method='get',
 258                 content=json.JSONEncoder().encode({}))
 259             if ret[0] != 0:
 260                 raise Exception(ret[1])
 261
 262             resp = json.JSONDecoder().decode(ret[1])
 263             vnf_status = ignorcase_get(resp, "vnfinstancestatus")
 264             resp_data = {"vnfInfo": {"vnfStatus": vnf_status}}
 265             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 266             queryVnfResponseSerializer = QueryVnfResponseSerializer(data=resp_data)
 267             if not queryVnfResponseSerializer.is_valid():
 268                 raise Exception(queryVnfResponseSerializer.errors)
 269             return Response(data=queryVnfResponseSerializer.data, status=status.HTTP_200_OK)
 270         except Exception as e:
 271             logger.error("Error occurred when querying VNF information,error:%s", e.message)
 272             logger.error(traceback.format_exc())
 273             return Response(data={'error': 'QueryVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 274
 275
 276 class JobView(APIView):
 277     @swagger_auto_schema(
 278         manual_parameters=[
 279             openapi.Parameter('responseId',
 280                               openapi.IN_QUERY,
 281                               "responseId",
 282                               type=openapi.TYPE_INTEGER
 283                               ),
 284         ],
 285         responses={
 286             status.HTTP_200_OK: JobQueryRespSerializer(),
 287             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 288         }
 289     )
 290     def get(self, request, vnfmid, jobid):
 291         try:
 292             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 293             ret = get_vnfminfo_from_nslcm(vnfmid)
 294             if ret[0] != 0:
 295                 raise Exception(ret[1])
 296
 297             vnfm_info = json.JSONDecoder().decode(ret[1])
 298             logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 299             operation_status_url = '/v1/jobs/{jobId}?NFVOID={nfvoId}&VNFMID={vnfmId}&ResponseID={responseId}'
 300             responseId = ignorcase_get(request.GET, 'responseId')
 301             query_url = operation_status_url.format(jobId=jobid, nfvoId=1, vnfmId=vnfmid, responseId=responseId)
 302             ret = restcall.call_req(
 303                 base_url=ignorcase_get(vnfm_info, 'url'),
 304                 user=ignorcase_get(vnfm_info, 'userName'),
 305                 passwd=ignorcase_get(vnfm_info, 'password'),
 306                 auth_type=restcall.rest_no_auth,
 307                 resource=query_url,
 308                 method='get',
 309                 content={})
 310
 311             if ret[0] != 0:
 312                 raise Exception(ret[1])
 313
 314             resp_data = json.JSONDecoder().decode(ret[1])
 315             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 316             jobQueryRespSerializer = JobQueryRespSerializer(data=resp_data)
 317             if not jobQueryRespSerializer.is_valid():
 318                 raise Exception(jobQueryRespSerializer.errors)
 319
 320             return Response(data=jobQueryRespSerializer.data, status=status.HTTP_200_OK)
 321         except Exception as e:
 322             logger.error("Error occurred when getting operation status information,error:%s", e.message)
 323             logger.error(traceback.format_exc())
 324             return Response(data={'error': 'QueryJob expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 325
 326
 327 class GrantVnf(APIView):
 328     @swagger_auto_schema(
 329         request_body=GrantReqSerializer(),
 330         responses={
 331             status.HTTP_201_CREATED: GrantRespSerializer(),
 332             status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
 333         }
 334     )
 335     def put(self, request):
 336         logger.debug("=====GrantVnf=====")
 337         try:
 338             logger.debug("request.data = %s", request.data)
 339             grantReqSerializer = GrantReqSerializer(data=request.data)
 340             if not grantReqSerializer.is_valid():
 341                 raise Exception(grantReqSerializer.errors)
 342
 343             logger.debug("grantReqSerializer.data = %s", grantReqSerializer.data)
 344             req_data = {
 345                 "vnfInstanceId": ignorcase_get(grantReqSerializer.data, "vnfistanceid"),
 346                 "vnfDescriptorId": "",
 347                 "addresource": [],
 348                 "additionalparam": {
 349                     "vnfmid": ignorcase_get(grantReqSerializer.data, "vnfmid"),
 350                     "vimid": ignorcase_get(grantReqSerializer.data, "vimid"),
 351                     "tenant": ignorcase_get(grantReqSerializer.data, "tenant")
 352                 }
 353             }
 354             if ignorcase_get(grantReqSerializer.data, "operationright") == 0:
 355                 req_data["lifecycleOperation"] = "Instantiate"
 356                 for vm in ignorcase_get(grantReqSerializer.data, "vmlist"):
 357                     for i in range(int(ignorcase_get(vm, "VMNumber"))):
 358                         req_data["addresource"].append(
 359                             {
 360                                 "type": "vdu",
 361                                 "resourceDefinitionId": i,
 362                                 "vdu": ignorcase_get(vm, "VMFlavor"),
 363                                 "vimid": ignorcase_get(vm, "vimid"),
 364                                 "tenant": ignorcase_get(vm, "tenant")})
 365
 366             logger.debug("req_data=%s", req_data)
 367             ret = req_by_msb('api/nslcm/v1/ns/grantvnf', "POST", content=json.JSONEncoder().encode(req_data))
 368             logger.info("ret = %s", ret)
 369             if ret[0] != 0:
 370                 raise Exception(ret[1])
 371
 372             resp = json.JSONDecoder().decode(ret[1])
 373             resp_data = {
 374                 'vimid': ignorcase_get(resp['vim'], 'vimid'),
 375                 'tenant': ignorcase_get(ignorcase_get(resp['vim'], 'accessinfo'), 'tenant')
 376             }
 377             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 378             grantRespSerializer = GrantRespSerializer(data=resp_data)
 379             if not grantRespSerializer.is_valid():
 380                 raise Exception(grantRespSerializer.errors)
 381
 382             logger.debug("grantRespSerializer.data=%s", grantRespSerializer.data)
 383             return Response(data=grantRespSerializer.data, status=status.HTTP_201_CREATED)
 384         except Exception as e:
 385             logger.error("Error occurred in Grant VNF, error: %s", e.message)
 386             logger.error(traceback.format_exc())
 387             return Response(data={'error': 'Grant expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 388
 389
 390 class Notify(APIView):
 391     @swagger_auto_schema(
 392         request_body=NotifyReqSerializer(),
 393         responses={
 394             status.HTTP_200_OK: 'Successfully',
 395             status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
 396         }
 397     )
 398     def post(self, request):
 399         try:
 400             logger.debug("[%s]request.data = %s", fun_name(), request.data)
 401             notifyReqSerializer = NotifyReqSerializer(data=request.data)
 402             if not notifyReqSerializer.is_valid():
 403                 raise Exception(notifyReqSerializer.errors)
 404
 405             logger.debug("[%s]notifyReqSerializer.data = %s", fun_name(), notifyReqSerializer.data)
 406             req_data = {
 407                 "status": "result",
 408                 "vnfInstanceId": ignorcase_get(notifyReqSerializer.data, "vnfinstanceid"),
 409                 "vnfmId": ignorcase_get(notifyReqSerializer.data, "vnfmid"),
 410                 "vimId": ignorcase_get(notifyReqSerializer.data, "vimid"),
 411                 "operation": ignorcase_get(notifyReqSerializer.data, "EventType"),
 412                 "jobId": "notMust",
 413                 "affectedVl": [],
 414                 "affectedCp": [],
 415                 "affectedVirtualStorage": [],
 416                 "affectedVnfc": [],
 417             }
 418
 419             extension = ignorcase_get(notifyReqSerializer.data, "extension")
 420             openo_notification = ignorcase_get(extension, "openo_notification")
 421             if openo_notification:
 422                 affectedvnfcs = ignorcase_get(openo_notification, "affectedVnfc")
 423                 affectedvls = ignorcase_get(openo_notification, "affectedvirtuallink")
 424                 affectedcps = ignorcase_get(openo_notification, "affectedCp")
 425                 vnfdmodule = ignorcase_get(openo_notification, "vnfdmodule")
 426             else:
 427                 affectedvnfcs = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvnfc")
 428                 affectedvls = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvl")
 429                 affectedcps = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedcp")
 430                 vnfdmodule = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "vnfdmodule")
 431
 432             req_data["vnfdmodule"] = vnfdmodule
 433
 434             for affectedvnfc in affectedvnfcs:
 435                 req_data["affectedVnfc"].append({
 436                     "vnfcInstanceId": ignorcase_get(affectedvnfc, "vnfcInstanceId"),
 437                     "vduId": ignorcase_get(affectedvnfc, "vduId"),
 438                     "changeType": ignorcase_get(affectedvnfc, "changeType"),
 439                     "vimId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "vimId"),
 440                     "vmId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceId"),
 441                     "vmName": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceName")
 442                 })
 443
 444             for affectedvl in affectedvls:
 445                 req_data["affectedVl"].append({
 446                     "vlInstanceId": ignorcase_get(affectedvl, "virtualLinkInstanceId"),
 447                     "changeType": ignorcase_get(affectedvl, "changeType"),
 448                     "vimId": ignorcase_get(ignorcase_get(affectedvl, "networkResource"), "vimId"),
 449                     "vldId": ignorcase_get(affectedvl, "virtuallinkdescid"),
 450                     "networkResource": {
 451                         "resourceType": "network",
 452                         "resourceId": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourceid"),
 453                         "resourceName": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourcename")
 454                     }
 455                 })
 456
 457             for affectedcp in affectedcps:
 458                 req_data["affectedCp"].append(affectedcp)
 459
 460             vnfmid = ignorcase_get(req_data, 'vnfmId')
 461             vnfInstanceId = ignorcase_get(req_data, 'vnfinstanceid')
 462             notify_url = 'api/nslcm/v1/ns/%s/vnfs/%s/Notify' % (vnfmid, vnfInstanceId)
 463             logger.debug("notify_url = %s", notify_url)
 464             logger.debug("req_data = %s", req_data)
 465             ret = req_by_msb(notify_url, "POST", content=json.JSONEncoder().encode(req_data))
 466
 467             logger.debug("[%s]data = %s", fun_name(), ret)
 468             if ret[0] != 0:
 469                 raise Exception(ret[1])
 470
 471             return Response(data=None, status=status.HTTP_200_OK)
 472         except Exception as e:
 473             logger.error("Error occurred in LCM notification,error: %s", e.message)
 474             logger.error(traceback.format_exc())
 475             return Response(data={'error': 'Notify expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 476
 477
 478 class Scale(APIView):
 479     @swagger_auto_schema(
 480         request_body=ScaleReqSerializer(),
 481         responses={
 482             status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
 483             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 484         }
 485     )
 486     def post(self, request, vnfmid, vnfInstanceId):
 487         logger.debug("====scale_vnf===")
 488         try:
 489             logger.debug("request.data = %s", request.data)
 490             logger.debug("requested_url = %s", request.get_full_path())
 491             scaleReqSerializer = ScaleReqSerializer(data=request.data)
 492             if not scaleReqSerializer.is_valid():
 493                 raise Exception(scaleReqSerializer.errors)
 494
 495             ret = get_vnfminfo_from_nslcm(vnfmid)
 496             if ret[0] != 0:
 497                 raise Exception(ret[1])
 498
 499             vnfm_info = json.JSONDecoder().decode(ret[1])
 500             scale_type = ignorcase_get(scaleReqSerializer.data, "type")
 501             aspect_id = ignorcase_get(scaleReqSerializer.data, "aspectId")
 502             number_of_steps = ignorcase_get(scaleReqSerializer.data, "numberOfSteps")
 503             data = {
 504                 'vnfmid': vnfmid,
 505                 'nfvoid': 1,
 506                 'scaletype': '0' if scale_type == 'SCALE_OUT' else '1',
 507                 'vmlist': [{
 508                     'VMNumber': number_of_steps,
 509                     'VMFlavor': aspect_id
 510                 }],
 511                 'extension': ''
 512             }
 513
 514             logger.debug("data = %s", data)
 515             ret = restcall.call_req(
 516                 base_url=ignorcase_get(vnfm_info, "url"),
 517                 user=ignorcase_get(vnfm_info, "userName"),
 518                 passwd=ignorcase_get(vnfm_info, "password"),
 519                 auth_type=restcall.rest_no_auth,
 520                 resource='/v1/vnfs/{vnfInstanceID}/scale'.format(vnfInstanceID=vnfInstanceId),
 521                 method='put',  # POST
 522                 content=json.JSONEncoder().encode(data))
 523             logger.debug("ret=%s", ret)
 524             if ret[0] != 0:
 525                 raise Exception('scale error')
 526
 527             scaleRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
 528             if not scaleRespSerializer.is_valid():
 529                 raise Exception(scaleRespSerializer.errors)
 530
 531             logger.debug("scaleRespSerializer.data=%s", scaleRespSerializer.data)
 532             return Response(data=scaleRespSerializer.data, status=status.HTTP_202_ACCEPTED)
 533         except Exception as e:
 534             logger.error("Error occurred when scaling VNF,error:%s", e.message)
 535             logger.error(traceback.format_exc())
 536             return Response(data={'error': 'Scale expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 537
 538
 539 class Heal(APIView):
 540     @swagger_auto_schema(
 541         request_body=HealReqSerializer(),
 542         responses={
 543             status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
 544             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 545         }
 546     )
 547     def post(self, request, vnfmid, vnfInstanceId):
 548         logger.debug("====heal_vnf===")
 549         try:
 550             logger.debug("request.data = %s", request.data)
 551             logger.debug("requested_url = %s", request.get_full_path())
 552             healReqSerializer = HealReqSerializer(data=request.data)
 553             if not healReqSerializer.is_valid():
 554                 raise Exception(healReqSerializer.errors)
 555
 556             logger.debug("healReqSerializer.data = %s", healReqSerializer.data)
 557             logger.debug("vnfmid = %s", vnfmid)
 558             ret = get_vnfminfo_from_nslcm(vnfmid)
 559             if ret[0] != 0:
 560                 raise Exception(ret[1])
 561
 562             vnfm_info = json.JSONDecoder().decode(ret[1])
 563             req_data = {
 564                 "action": ignorcase_get(healReqSerializer.data, 'action'),
 565                 "lifecycleoperation": "operate",
 566                 "isgrace": "force",
 567                 "affectedvm": [],
 568             }
 569             affectedvm = ignorcase_get(healReqSerializer.data, 'affectedvm')
 570             if isinstance(affectedvm, list):
 571                 req_data['affectedvm'] = affectedvm
 572             else:
 573                 req_data['affectedvm'].append(affectedvm)
 574
 575             logger.debug("req_data = %s", req_data)
 576             ret = restcall.call_req(
 577                 base_url=ignorcase_get(vnfm_info, "url"),
 578                 user=ignorcase_get(vnfm_info, "userName"),
 579                 passwd=ignorcase_get(vnfm_info, "password"),
 580                 auth_type=restcall.rest_no_auth,
 581                 resource='/api/v1/nf_m_i/nfs/{vnfInstanceID}/vms/operation'.format(vnfInstanceID=vnfInstanceId),
 582                 method='post',
 583                 content=json.JSONEncoder().encode(req_data))
 584             logger.debug("ret=%s", ret)
 585             if ret[0] != 0:
 586                 raise Exception('heal error')
 587
 588             healRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
 589             if not healRespSerializer.is_valid():
 590                 raise Exception(healRespSerializer.errors)
 591
 592             logger.debug("healRespSerializer.data=%s", healRespSerializer.data)
 593             return Response(data=healRespSerializer.data, status=status.HTTP_202_ACCEPTED)
 594         except Exception as e:
 595             logger.error("Error occurred when healing VNF,error:%s", e.message)
 596             logger.error(traceback.format_exc())
 597             return Response(data={'error': 'Heal expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 598
 599
 600 def get_vdus(nf_model, aspect_id):
 601     associated_group = ''
 602     members = []
 603     vnf_flavours = nf_model['vnf_flavours']
 604     for vnf_flaour in vnf_flavours:
 605         scaling_aspects = vnf_flaour['scaling_aspects']
 606         for aspect in scaling_aspects:
 607             if aspect_id == aspect['id']:
 608                 associated_group = aspect['associated_group']
 609                 break
 610     if not associated_group:
 611         logger.error('Cannot find the corresponding element group')
 612         raise Exception('Cannot find the corresponding element group')
 613     for element_group in nf_model['element_groups']:
 614         if element_group['group_id'] == associated_group:
 615             members = element_group['members']
 616     if not members:
 617         logger.error('Cannot find the corresponding members')
 618         raise Exception('Cannot find the corresponding members')
 619     return members
 620
 621
 622 class SampleList(APIView):
 623     @swagger_auto_schema(
 624         responses={
 625             status.HTTP_200_OK: 'Successfully'})
 626     def get(self, request):
 627         logger.debug("get")
 628         return Response({"status": "active"})
 629
 630
 631 class Subscribe(APIView):
 632     @swagger_auto_schema(
 633         responses={
 634             status.HTTP_200_OK: SubscribesRespSerializer(),
 635             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 636         }
 637     )
 638     def get(self, request):
 639         logger.debug("====Subscribe get====")
 640         resp_data = {
 641             "subscriptions": [{
 642                 "subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657",
 643                 "filter": [{
 644                     "vendor": "ZTE",
 645                     "type": "vCPE",
 646                 }],
 647                 "notificationuri": " https://127.0.0.1:80/v2/vnfm/vnfds/notification",
 648             }]
 649         }
 650         return Response(data=resp_data, status=status.HTTP_200_OK)
 651
 652     @swagger_auto_schema(
 653         request_body=SubscribeReqSerializer(),
 654         responses={
 655             status.HTTP_201_CREATED: SubscribeRespSerializer(),
 656             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 657         }
 658     )
 659     def post(self, request):
 660         logger.debug("====Subscribe post====")
 661         resp_data = {"subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657"}
 662         return Response(data=resp_data, status=status.HTTP_201_CREATED)
 663
 664
 665 class SubscribeDetail(APIView):
 666     def delete(self, request, subscribeId):
 667         logger.debug("====SubscribeDetail delete %s====", subscribeId)
 668         return Response(status=status.HTTP_204_NO_CONTENT)
 669
 670
 671 class VnfPkgs(APIView):
 672     def get(self, request):
 673         logger.debug("====VnfPkgs get====")
 674         resp_data = {
 675             "data": [{
 676                 "packageid": "924fc980-4530-11e9-ae68-acc860114657",
 677                 "vendor": "ZTE",
 678                 "type": "vCPE",
 679                 "vnfdfile": "MRP6600_FS_SRIOV_4NIC_200W.zip",
 680                 "imagefiles": ["MRP6600_FS_SRIOV_MRPISU_IMGV500R008C20SPC030T.tar"],
 681                 "swfiles": ["MRP6600_SRV_V500R008C20SPC030T.tar"],
 682                 "description": "This is a service for vCPE.",
 683             }]
 684         }
 685         return Response(data=resp_data, status=status.HTTP_200_OK)
 686
 687
 688 class VnfPkg(APIView):
 689     def get(self, request, packageId, fileName):
 690         logger.debug("====VnfPkg get====%s, %s", packageId, fileName)
 691         file_range = request.META.get('RANGE')
 692         logger.debug('file_range: %s' % file_range)
 693         # TODO: get filepath
 694         local_file_path = fileName
 695         start, end = parse_file_range(local_file_path, file_range)
 696         file_iterator = read(local_file_path, start, end)
 697         return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)
 698
 699
 700 class NfvoInfo(APIView):
 701     def put(self, request, vnfmid):
 702         logger.debug("====NfvoInfo put====%s", vnfmid)
 703         req_data = {
 704             "nfvoid": request.data.get("nfvoid", "1"),
 705             "vnfmid": vnfmid,
 706             "nfvourl": request.data.get("nfvourl", "http://127.0.0.1:80")
 707         }
 708         ret = get_vnfminfo_from_nslcm(vnfmid)
 709         if ret[0] != 0:
 710             raise Exception(ret[1])
 711
 712         vnfm_info = json.JSONDecoder().decode(ret[1])
 713         logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
 714         ret = restcall.call_req(
 715             base_url=ignorcase_get(vnfm_info, "url"),
 716             user=ignorcase_get(vnfm_info, "userName"),
 717             passwd=ignorcase_get(vnfm_info, "password"),
 718             auth_type=restcall.rest_no_auth,
 719             resource="v1/nfvo/info",
 720             method='put',
 721             content=json.dumps(req_data))
 722         if ret[0] != 0:
 723             raise Exception(ret[1])
 724         logger.debug("update nfvo info successfully.")