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