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