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