gvnfmadapter/driver/interfaces/views.py

   1 # Copyright 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 time
  19 import traceback
  20
  21 from drf_yasg.utils import swagger_auto_schema
  22 from rest_framework import status
  23 from rest_framework.response import Response
  24 from rest_framework.views import APIView
  25
  26 from driver.interfaces.serializers.serializers import VnfInstReqParamsSerializer, ResponseSerializer
  27 from driver.interfaces.serializers.serializers import VnfNotifyReqSerializer, VNFLCMOpOccSerializer
  28 from driver.interfaces.serializers.serializers import VnfOperRespSerializer
  29 from driver.interfaces.serializers.serializers import VnfTermReqSerializer, VnfQueryRespSerializer
  30 from driver.interfaces.serializers.grant_request import GrantRequestSerializer
  31 from driver.interfaces.serializers.grant import GrantSerializer
  32 from driver.interfaces.serializers.lccn_subscription import LccnSubscriptionSerializer
  33 from driver.interfaces.serializers.lccn_subscription_request import LccnSubscriptionRequestSerializer
  34 from driver.pub.exceptions import GvnfmDriverException
  35 from driver.pub.utils import restcall
  36 from driver.pub.utils.restcall import req_by_msb
  37 from driver.interfaces.serializers.operate_request import VnfOperateRequestSerializer
  38 from driver.interfaces.serializers.heal_request import HealVnfRequestSerializerToVnfm, VnfHealRequestSerializer
  39 from driver.interfaces.serializers.response import ProblemDetailSerializer
  40
  41 logger = logging.getLogger(__name__)
  42
  43
  44 class VnfInstInfo(APIView):
  45     @swagger_auto_schema(
  46         request_body=VnfInstReqParamsSerializer(),
  47         responses={
  48             status.HTTP_201_CREATED: ResponseSerializer(),
  49             status.HTTP_404_NOT_FOUND: "The vnfm instance id is wrong",
  50             status.HTTP_500_INTERNAL_SERVER_ERROR: "The url is invalid"
  51         }
  52     )
  53     def post(self, request, vnfmtype, vnfmid):
  54         logger.debug("instantiate_vnf--post::> %s" % request.data)
  55         logger.debug("Create vnf begin!")
  56         try:
  57             requestSerializer = VnfInstReqParamsSerializer(data=request.data)
  58             request_isValid = requestSerializer.is_valid()
  59             if not request_isValid:
  60                 raise Exception(requestSerializer.errors)
  61
  62             # requestData = requestSerializer.data
  63             requestData = request.data
  64             input_data = {
  65                 "vnfdId": ignorcase_get(requestData, "vnfDescriptorId"),
  66                 "vnfInstanceName": ignorcase_get(requestData, "vnfInstanceName"),
  67                 "vnfInstanceDescription": ignorcase_get(requestData, "vnfInstanceDescription"),
  68                 "vnfmInstId": vnfmid
  69             }
  70             vnfm_id = vnfmid
  71             logger.debug("do_createvnf: request data=[%s],input_data=[%s],vnfm_id=[%s]",
  72                          request.data, input_data, vnfm_id)
  73             resp = do_createvnf(vnfm_id, input_data)
  74             logger.debug("do_createvnf: response data=[%s]", resp)
  75             logger.debug("Create vnf end!")
  76
  77             logger.debug("Instantiate vnf start!")
  78             vnfInstanceId = resp["id"]
  79             input_data = {
  80                 "flavourId": ignorcase_get(requestData, "flavourId"),
  81                 "extVirtualLinks": ignorcase_get(requestData, "extVirtualLink"),
  82                 "additionalParams": ignorcase_get(requestData, "additionalParam"),
  83             }
  84             logger.debug("do_instvnf: vnfInstanceId=[%s],request data=[%s],input_data=[%s],vnfm_id=[%s]",
  85                          vnfInstanceId, request.data, input_data, vnfm_id)
  86             resp = do_instvnf(vnfInstanceId, vnfm_id, input_data)
  87             logger.debug("do_instvnf: response data=[%s]", resp)
  88             resp_data = {
  89                 "vnfInstanceId": vnfInstanceId,
  90                 "jobId": ignorcase_get(resp, "jobId")
  91             }
  92             logger.debug("Instantiate vnf end!")
  93             return Response(data=resp_data, status=status.HTTP_201_CREATED)
  94         except GvnfmDriverException as e:
  95             logger.error('instantiate vnf failed, detail message: %s' % e.message)
  96             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  97         except:
  98             logger.error(traceback.format_exc())
  99             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 100
 101
 102 class VnfTermInfo(APIView):
 103     @swagger_auto_schema(
 104         request_body=VnfTermReqSerializer(),
 105         responses={
 106             status.HTTP_201_CREATED: ResponseSerializer(),
 107             status.HTTP_404_NOT_FOUND: "The vnfmid and vnfInstanceId are wrong",
 108             status.HTTP_500_INTERNAL_SERVER_ERROR: "The url is invalid"
 109         }
 110     )
 111     def post(self, request, vnfmtype, vnfmid, vnfInstanceId):
 112         logger.debug("terminate_vnf--post::> %s" % request.data)
 113         vnfm_id = vnfmid
 114         try:
 115             term_type = ignorcase_get(request.data, "terminationType")
 116             input_data = {
 117                 "terminationType": term_type.upper() if term_type else "FORCEFUL"
 118             }
 119             term_timeout = ignorcase_get(request.data, "gracefulTerminationTimeout")
 120             if term_timeout:
 121                 input_data["gracefulTerminationTimeout"] = int(term_timeout)
 122
 123             logger.debug("do_terminatevnf: vnfm_id=[%s],vnfInstanceId=[%s],input_data=[%s]",
 124                          vnfm_id, vnfInstanceId, input_data)
 125             resp = do_terminatevnf(vnfm_id, vnfInstanceId, input_data)
 126             logger.debug("terminate_vnf: response data=[%s]", resp)
 127
 128             jobId = ignorcase_get(resp, "jobId")
 129             logger.debug("wait4job: vnfm_id=[%s],jobId=[%s]", vnfm_id, jobId)
 130             resp = wait4job(vnfm_id, jobId)
 131             logger.debug("[wait4job] response=[%s]", resp)
 132
 133             resp = do_deletevnf(vnfm_id, vnfInstanceId)
 134             logger.debug("do_deletevnf: response data=[%s]", resp)
 135
 136             resp_data = {
 137                 "vnfInstanceId": vnfInstanceId,
 138                 "jobId": jobId
 139             }
 140             return Response(data=resp_data, status=status.HTTP_201_CREATED)
 141         except GvnfmDriverException as e:
 142             logger.error('Terminate vnf failed, detail message: %s' % e.message)
 143             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 144         except:
 145             logger.error(traceback.format_exc())
 146             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 147
 148
 149 class VnfQueryInfo(APIView):
 150     @swagger_auto_schema(
 151         responses={
 152             status.HTTP_201_CREATED: VnfQueryRespSerializer(),
 153             status.HTTP_404_NOT_FOUND: "The vnfmid and vnfInstanceId are wrong",
 154             status.HTTP_500_INTERNAL_SERVER_ERROR: "The url is invalid"
 155         }
 156     )
 157     def get(self, request, vnfmtype, vnfmid, vnfInstanceId):
 158         logger.debug("query_vnf--post::> %s" % request.data)
 159         vnfm_id = vnfmid
 160         try:
 161             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 162             resp = do_queryvnf(request, vnfm_id, vnfInstanceId)
 163             query_vnf_resp_mapping = {
 164                 "vnfInstanceId": "",
 165                 "vnfInstanceName": "",
 166                 "vnfInstanceDescription": "",
 167                 "vnfdId": "",
 168                 "vnfPackageId": "",
 169                 "version": "",
 170                 "vnfProvider": "",
 171                 "vnfType": "",
 172                 "vnfStatus": ""
 173             }
 174             ResponseInfo = ignorcase_get(resp, "ResponseInfo")
 175             resp_response_data = mapping_conv(query_vnf_resp_mapping, ResponseInfo)
 176             resp_data = {
 177                 "vnfInfo": resp_response_data
 178             }
 179             id = ignorcase_get(ResponseInfo, "id")
 180             if id:
 181                 resp_data["vnfInfo"]["vnfInstanceId"] = id
 182             vnfPkgId = ignorcase_get(ResponseInfo, "vnfPkgId")
 183             if vnfPkgId:
 184                 resp_data["vnfInfo"]["vnfPackageId"] = vnfPkgId
 185             vnfSoftwareVersion = ignorcase_get(ResponseInfo, "vnfSoftwareVersion")
 186             if vnfSoftwareVersion:
 187                 resp_data["vnfInfo"]["version"] = vnfSoftwareVersion
 188             if ignorcase_get(ResponseInfo, "instantiationState") == "INSTANTIATED":
 189                 resp_data["vnfInfo"]["vnfStatus"] = "ACTIVE"
 190             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 191             return Response(data=resp_data, status=status.HTTP_200_OK)
 192         except GvnfmDriverException as e:
 193             logger.error('Query vnf failed, detail message: %s' % e.message)
 194             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 195         except:
 196             logger.error(traceback.format_exc())
 197             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 198
 199
 200 class VnfOperInfo(APIView):
 201     @swagger_auto_schema(
 202         responses={
 203             status.HTTP_201_CREATED: VnfOperRespSerializer(),
 204             status.HTTP_404_NOT_FOUND: "The vnfmid, jobid and responseId are wrong",
 205             status.HTTP_500_INTERNAL_SERVER_ERROR: "The url is invalid"
 206         }
 207     )
 208     def get(self, request, vnfmtype, vnfmid, jobid):
 209         logger.debug("operation_status--post::> %s" % request.data)
 210         try:
 211             logger.debug("[%s] request.data=%s", fun_name(), request.data)
 212             vnfm_id = vnfmid
 213             jobId = jobid
 214             responseId = ignorcase_get(request.META, 'responseId')
 215             logger.debug("[operation_status] vnfm_id=%s", vnfm_id)
 216             vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 217             logger.debug("[operation_status] vnfm_info=[%s]", vnfm_info)
 218
 219             ret = call_vnfm("api/vnflcm/v1/vnf_lc_ops/%s?responseId=%s" % (jobId, responseId), "GET", vnfm_info)
 220             if ret[0] != 0:
 221                 logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 222                 raise GvnfmDriverException('Failed to query vnf operation status.')
 223             resp_data = json.JSONDecoder().decode(ret[1])
 224             logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
 225             # ResponseInfo = ignorcase_get(resp_data, "ResponseInfo")
 226             responseDescriptor = ignorcase_get(resp_data, "responseDescriptor")
 227             status_tmp = ignorcase_get(responseDescriptor, "status")
 228             # del responseDescriptor["lcmOperationStatus"]
 229             responseDescriptor["status"] = status_tmp
 230             operation_data = {
 231                 "jobId": ignorcase_get(resp_data, "jobId"),
 232                 "responseDescriptor": responseDescriptor
 233             }
 234             return Response(data=operation_data, status=status.HTTP_200_OK)
 235         except GvnfmDriverException as e:
 236             logger.error('Query vnf failed, detail message: %s' % e.message)
 237             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 238         except:
 239             logger.error(traceback.format_exc())
 240             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 241
 242
 243 class VnfGrantInfo(APIView):
 244     @swagger_auto_schema(
 245         request_body=GrantRequestSerializer(),  # TODO: not used
 246         responses={
 247             status.HTTP_201_CREATED: GrantSerializer(),
 248             status.HTTP_404_NOT_FOUND: "The request body is wrong",
 249             status.HTTP_500_INTERNAL_SERVER_ERROR: "The url is invalid"
 250         }
 251     )
 252     def put(self, request, vnfmtype):
 253         try:
 254             logger.debug("[grantvnf] req_data = %s", request.data)
 255             grant_request = GrantRequestSerializer(data=request.data)
 256             if not grant_request.is_valid():
 257                 raise GvnfmDriverException(grant_request.error_messages)
 258             ret = req_by_msb('api/nslcm/v2/grants', "POST", content=json.JSONEncoder().encode(request.data))
 259             logger.debug("ret = %s", ret)
 260             if ret[0] != 0:
 261                 logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 262                 raise GvnfmDriverException('Failed to grant vnf.')
 263             resp = json.JSONDecoder().decode(ret[1])
 264             grant = GrantSerializer(data=resp)
 265             if not grant.is_valid():
 266                 logger.warn(grant.error_messages)
 267                 # raise GvnfmDriverException(grant.error_messages)
 268             logger.debug("[%s]resp_data=%s", fun_name(), resp)
 269             return Response(data=resp, status=status.HTTP_201_CREATED)
 270         except GvnfmDriverException as e:
 271             logger.error('Grant vnf failed, detail message: %s' % e.message)
 272             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 273         except:
 274             logger.error(traceback.format_exc())
 275             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 276
 277
 278 class VnfNotifyInfo(APIView):
 279     @swagger_auto_schema(
 280         request_body=VnfNotifyReqSerializer(),
 281         responses={
 282             status.HTTP_201_CREATED: "Successful Notify",
 283             status.HTTP_404_NOT_FOUND: "The request body is wrong",
 284             status.HTTP_500_INTERNAL_SERVER_ERROR: "The url is invalid"
 285         }
 286     )
 287     def post(self, request, vnfmtype):  # TODO: not compatable with VnfIdentifierCreationNotification and VnfIdentifierDeletionNotification
 288         try:
 289             logger.debug("[%s]req_data = %s", fun_name(), request.data)
 290             vnfminstid = ignorcase_get(request.data, 'vnfmInstId')
 291             vnfinstanceid = ignorcase_get(request.data, 'vnfInstanceId')
 292             request.data.pop("vnfmInstId")
 293             ret = req_by_msb("api/nslcm/v2/ns/%s/vnfs/%s/Notify" % (vnfminstid, vnfinstanceid), "POST",
 294                              json.JSONEncoder().encode(request.data))
 295             logger.debug("[%s]data = %s", fun_name(), ret)
 296             if ret[0] != 0:
 297                 logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 298                 raise GvnfmDriverException('Failed to notify vnf.')
 299             return Response(data=None, status=status.HTTP_200_OK)
 300         except GvnfmDriverException as e:
 301             logger.error('Grant vnf failed, detail message: %s' % e.message)
 302             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 303         except:
 304             logger.error(traceback.format_exc())
 305             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 306
 307
 308 class VnfOperateView(APIView):
 309     @swagger_auto_schema(
 310         request_body=VnfOperateRequestSerializer(),
 311         responses={
 312             status.HTTP_202_ACCEPTED: "Success",
 313             status.HTTP_404_NOT_FOUND: ProblemDetailSerializer(),
 314             status.HTTP_409_CONFLICT: ProblemDetailSerializer(),
 315             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 316         }
 317     )
 318     def post(self, request, vnfmtype, vnfmid, vnfInstanceId):
 319         logger.debug("operate_vnf--post::> %s" % request.data)
 320         logger.debug("Operate vnf begin!")
 321         try:
 322             requestSerializer = VnfOperateRequestSerializer(data=request.data)
 323             request_isValid = requestSerializer.is_valid()
 324             if not request_isValid:
 325                 raise Exception(requestSerializer.errors)
 326             logger.debug("Operate vnf start!")
 327             logger.debug("do_operate: vnfmid=[%s],vnfInstanceId=[%s],request data=[%s]",
 328                          vnfmid, vnfInstanceId, request.data)
 329             statusCode, resp, location = do_lcmVnf(vnfmid, vnfInstanceId, request.data, "operate")
 330             logger.debug("do_operate: response data=[%s]", resp)
 331             logger.debug("Operate vnf end!")
 332             ret = int(statusCode)
 333             if ret == status.HTTP_404_NOT_FOUND:
 334                 return Response(data=resp, status=status.HTTP_404_NOT_FOUND)
 335             elif ret == status.HTTP_409_CONFLICT:
 336                 return Response(data=resp, status=status.HTTP_409_CONFLICT)
 337             response = Response(data=resp, status=status.HTTP_202_ACCEPTED)
 338             response["Location"] = location
 339             return response
 340         except GvnfmDriverException as e:
 341             logger.error('operate vnf failed, detail message: %s' % e.message)
 342             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 343         except:
 344             logger.error(traceback.format_exc())
 345             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 346
 347
 348 class VnfHealView(APIView):
 349     @swagger_auto_schema(
 350         request_body=VnfHealRequestSerializer(),
 351         responses={
 352             status.HTTP_202_ACCEPTED: "Success",
 353             status.HTTP_404_NOT_FOUND: ProblemDetailSerializer(),
 354             status.HTTP_409_CONFLICT: ProblemDetailSerializer(),
 355             status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
 356         }
 357     )
 358     def post(self, request, vnfmtype, vnfmid, vnfInstanceId):
 359         logger.debug("Heal_vnf--post::> %s" % request.data)
 360         logger.debug("Heal vnf begin!")
 361         try:
 362             requestSerializer = VnfHealRequestSerializer(data=request.data)
 363             request_isValid = requestSerializer.is_valid()
 364             if not request_isValid:
 365                 raise Exception(requestSerializer.errors)
 366             healdata = {
 367                 u"additionalParams": {
 368                     u"action": ignorcase_get(request.data, "action"),
 369                     u"affectedvm": ignorcase_get(request.data, "affectedvm")
 370                 }
 371             }
 372             input_data = HealVnfRequestSerializerToVnfm(data=healdata)
 373             resp_isvalid = input_data.is_valid()
 374             if not resp_isvalid:
 375                 raise GvnfmDriverException(input_data.errors)
 376             logger.debug("Heal vnf start!")
 377             logger.debug("do_heal: vnfmid=[%s],vnfInstanceId=[%s],request data=[%s]",
 378                          vnfmid, vnfInstanceId, input_data)
 379             statusCode, resp, location = do_lcmVnf(vnfmid, vnfInstanceId, input_data.data, "heal")
 380             logger.debug("do_heal: response data=[%s]", resp)
 381             logger.debug("Heal vnf end!")
 382             ret = int(statusCode)
 383             if ret == status.HTTP_404_NOT_FOUND:
 384                 return Response(data=resp, status=status.HTTP_404_NOT_FOUND)
 385             elif ret == status.HTTP_409_CONFLICT:
 386                 return Response(data=resp, status=status.HTTP_409_CONFLICT)
 387             response = Response(data=None, status=status.HTTP_202_ACCEPTED)
 388             response["Location"] = location
 389             return response
 390         except GvnfmDriverException as e:
 391             logger.error('Heal vnf failed, detail message: %s' % e.message)
 392             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 393         except:
 394             logger.error(traceback.format_exc())
 395             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 396
 397
 398 class VnfPkgsInfo(APIView):
 399     def get(request, *args, **kwargs):
 400         try:
 401             logger.debug("Enter %s", fun_name())
 402             ret = req_by_msb("api/nslcm/v1/vnfpackage", "GET")
 403             if ret[0] != 0:
 404                 logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 405                 raise GvnfmDriverException('Failed to get vnfpkgs.')
 406             resp = json.JSONDecoder().decode(ret[1])
 407             return Response(data=resp, status=status.HTTP_200_OK)
 408         except GvnfmDriverException as e:
 409             logger.error('Get vnfpkgs failed, detail message: %s' % e.message)
 410             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 411         except:
 412             logger.error(traceback.format_exc())
 413             return Response(data={'error': 'unexpected exception'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 414
 415
 416 class QuerySingleVnfLcmOpOcc(APIView):
 417     @swagger_auto_schema(
 418         responses={
 419             status.HTTP_200_OK: VNFLCMOpOccSerializer(),
 420             status.HTTP_500_INTERNAL_SERVER_ERROR: ""
 421         }
 422     )
 423     def get(self, request, vnfmtype, vnfmid, lcmopoccid):
 424         logger.debug("[%s]LCMOpOccId = %s", fun_name(), lcmopoccid)
 425         try:
 426             vnfm_info = get_vnfminfo_from_nslcm(vnfmid)
 427             logger.debug("[get lcm op occ] vnfm_info=[%s]", vnfm_info)
 428             ret = call_vnfm("api/vnflcm/v1/vnf_lcm_op_occs/%s" % lcmopoccid, "GET", vnfm_info)
 429             if ret[0] != 0:
 430                 logger.error("Status code is %s. detail is %s.", ret[2], ret[1])
 431                 raise GvnfmDriverException("Failed to query vnf lcm op occ %s" % lcmopoccid)
 432             resp_data = json.JSONDecoder().decode(ret[1])
 433             vnf_lcm_op_occ_serializer = VNFLCMOpOccSerializer(data=resp_data)
 434             if vnf_lcm_op_occ_serializer.is_valid():
 435                 logger.debug("[%s]resp_data=%s" % (fun_name(), resp_data))
 436                 return Response(data=vnf_lcm_op_occ_serializer.data, status=status.HTTP_200_OK)
 437             else:
 438                 raise GvnfmDriverException(vnf_lcm_op_occ_serializer.errors)
 439         except GvnfmDriverException as e:
 440             logger.error("Query vnflcmopocc failed, detail message: %s" % e.message)
 441             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 442         except:
 443             logger.error(traceback.format_exc())
 444             return Response(data={'error': traceback.format_exc()}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 445
 446
 447 class Subscription(APIView):
 448     @swagger_auto_schema(
 449         request_body=LccnSubscriptionRequestSerializer(),
 450         responses={
 451             status.HTTP_201_CREATED: LccnSubscriptionSerializer(),
 452             status.HTTP_303_SEE_OTHER: None,
 453             status.HTTP_500_INTERNAL_SERVER_ERROR: "INTERNAL_SERVER_ERROR"
 454         }
 455     )
 456     def post(self, request, vnfmtype, vnfmid):
 457         logger.debug("Subscription--post::> %s" % request.data)
 458         logger.debug("Subscription begin!")
 459         try:
 460             lccn_subscription_request_serializer = LccnSubscriptionRequestSerializer(data=request.data)
 461             if not lccn_subscription_request_serializer.is_valid():
 462                 raise GvnfmDriverException(lccn_subscription_request_serializer.error_messages)
 463             resp_data = do_subscription(request.data, vnfmid)
 464             lccn_subscription_serializer = LccnSubscriptionSerializer(data=resp_data)
 465             if not lccn_subscription_serializer.is_valid():
 466                 logger.debug("[%s]resp_data=%s" % (fun_name(), resp_data))
 467                 raise GvnfmDriverException(lccn_subscription_serializer.errors)
 468             logger.debug("Subscription end!")
 469             return Response(data=lccn_subscription_serializer.data, status=status.HTTP_201_CREATED)
 470         except GvnfmDriverException as e:
 471             logger.error(e.message)
 472             return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 473         except Exception as e:
 474             logger.error(e.message)
 475             logger.error(traceback.format_exc())
 476             return Response(status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 477
 478
 479 def call_vnfm(resource, method, vnfm_info, data=""):
 480     ret = restcall.call_req(
 481         base_url=ignorcase_get(vnfm_info, "url"),
 482         user=ignorcase_get(vnfm_info, "userName"),
 483         passwd=ignorcase_get(vnfm_info, "password"),
 484         auth_type=restcall.rest_no_auth,
 485         resource=resource,
 486         method=method,
 487         content=json.JSONEncoder().encode(data))
 488     return ret
 489
 490
 491 def mapping_conv(keyword_map, rest_return):
 492     resp_data = {}
 493     for param in keyword_map:
 494         # if keyword_map[param]:
 495         if isinstance(keyword_map[param], dict):
 496             resp_data[param] = mapping_conv(keyword_map[param], ignorcase_get(rest_return, param))
 497         else:
 498             value = ignorcase_get(rest_return, param)
 499             if value:
 500                 resp_data[param] = value
 501     return resp_data
 502
 503
 504 def fun_name():
 505     return "=========%s=========" % inspect.stack()[1][3]
 506
 507
 508 def ignorcase_get(args, key):
 509     if not key:
 510         return ""
 511     if not args:
 512         return ""
 513     if key in args:
 514         return args[key]
 515     for old_key in args:
 516         if old_key.upper() == key.upper():
 517             return args[old_key]
 518     return ""
 519
 520
 521 def get_vnfminfo_from_nslcm(vnfm_id):
 522     logger.debug("[get_vnfminfo_from_nslcm] vnfm_id=[%s]", vnfm_id)
 523     # ret = req_by_msb("api/aai-esr-server/v1/vnfms/%s" % vnfm_id, "GET")
 524     ret = req_by_msb("api/nslcm/v1/vnfms/%s" % vnfm_id, "GET")
 525     logger.debug("[get_vnfminfo_from_nslcm] response=%s", ret)
 526     if ret[0] != 0:
 527         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 528         raise GvnfmDriverException("Failed to query vnfm(%s) from nslcm." % vnfm_id)
 529     return json.JSONDecoder().decode(ret[1])
 530
 531
 532 def wait4job(vnfm_id, job_id, gracefulTerminationTimeout=1200, retry_count=60, interval_second=3):
 533     logger.debug("[wait4job] vnfm_id=[%s],jobId=[%s],gracefulTerminationTimeout=[%s]",
 534                  vnfm_id, job_id, gracefulTerminationTimeout)
 535     count = 0
 536     response_id, new_response_id = 0, 0
 537     job_end_normal, job_timeout = False, True
 538     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 539     logger.debug("[do_terminatevnf] vnfm_info=[%s]", vnfm_info)
 540     while count < retry_count:
 541         count = count + 1
 542         time.sleep(interval_second)
 543         ret = call_vnfm("api/vnflcm/v1/vnf_lc_ops/%s?responseId=%s" % (job_id, response_id), "GET", vnfm_info)
 544         if ret[0] != 0:
 545             logger.error("Failed to query job: %s:%s", ret[2], ret[1])
 546             continue
 547         job_result = json.JSONDecoder().decode(ret[1])
 548         if "responseDescriptor" not in job_result:
 549             logger.error("Job(%s) does not exist.", job_id)
 550             continue
 551         progress = str(job_result["responseDescriptor"]["progress"])
 552         new_response_id = job_result["responseDescriptor"]["responseId"]
 553         job_desc = job_result["responseDescriptor"]["statusDescription"]
 554         if new_response_id != response_id:
 555             logger.debug("%s:%s:%s", progress, new_response_id, job_desc)
 556             response_id = new_response_id
 557             count = 0
 558         if progress == "255":
 559             job_timeout = False
 560             logger.error("Job(%s) failed: %s", job_id, job_desc)
 561             break
 562         elif progress == "100":
 563             job_end_normal, job_timeout = True, False
 564             logger.debug("Job(%s) ended normally,job_end_normal=[%s],job_timeout=[%s]",
 565                          job_id, job_end_normal, job_timeout)
 566             return {"success": "success"}
 567     if job_timeout:
 568         logger.error("Job(%s) timeout", job_id)
 569     raise GvnfmDriverException("Fail to get job status!")
 570
 571
 572 def do_createvnf(vnfm_id, data):
 573     logger.debug("[%s] request.data=%s", fun_name(), data)
 574     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 575     logger.debug("[do_createvnf] vnfm_info=[%s]", vnfm_info)
 576     ret = call_vnfm("api/vnflcm/v1/vnf_instances", "POST", vnfm_info, data)
 577     logger.debug("[%s] call_req ret=%s", fun_name(), ret)
 578     if ret[0] != 0:
 579         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 580         raise GvnfmDriverException('Failed to create vnf.')
 581     return json.JSONDecoder().decode(ret[1])
 582
 583
 584 def do_instvnf(vnfInstanceId, vnfm_id, data):
 585     logger.debug("[%s] request.data=%s", fun_name(), data)
 586     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 587     logger.debug("[do_instvnf] vnfm_info=[%s]", vnfm_info)
 588     ret = call_vnfm("api/vnflcm/v1/vnf_instances/%s/instantiate" % vnfInstanceId, "POST", vnfm_info, data)
 589     logger.debug("[%s] call_req ret=%s", fun_name(), ret)
 590     if ret[0] != 0:
 591         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 592         raise GvnfmDriverException('Failed to inst vnf.')
 593     return json.JSONDecoder().decode(ret[1])
 594
 595
 596 def do_terminatevnf(vnfm_id, vnfInstanceId, data):
 597     logger.debug("[%s] request.data=%s", fun_name(), data)
 598     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 599     logger.debug("[do_terminatevnf] vnfm_info=[%s]", vnfm_info)
 600     ret = call_vnfm("api/vnflcm/v1/vnf_instances/%s/terminate" % vnfInstanceId, "POST", vnfm_info, data)
 601     if ret[0] != 0:
 602         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 603         raise GvnfmDriverException('Failed to terminate vnf.')
 604     return json.JSONDecoder().decode(ret[1])
 605
 606
 607 def do_deletevnf(vnfm_id, vnfInstanceId):
 608     logger.debug("[%s] vnfm_id=%s, vnfInstanceId=%s", fun_name(), vnfm_id, vnfInstanceId)
 609     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 610     logger.debug("[do_deletevnf] vnfm_info=[%s]", vnfm_info)
 611     ret = call_vnfm("api/vnflcm/v1/vnf_instances/%s" % vnfInstanceId, "DELETE", vnfm_info)
 612     if ret[0] != 0:
 613         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 614         raise GvnfmDriverException('Failed to delete vnf.')
 615     return ret[1]
 616
 617
 618 def do_lcmVnf(vnfm_id, vnfInstanceId, data, lcmType):
 619     logger.debug("[%s] request.data=%s", fun_name(), data)
 620     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 621     logger.debug("[do_lcmVnf] vnfm_info=[%s]", vnfm_info)
 622     ret = call_vnfm("api/vnflcm/v1/vnf_instances/%s/%s" % (vnfInstanceId, lcmType), "POST", vnfm_info, data)
 623     if ret[0] != 0 and int(ret[2]) != status.HTTP_404_NOT_FOUND and int(ret[2]) != status.HTTP_409_CONFLICT:
 624         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 625         raise GvnfmDriverException('Failed to Operate vnf.')
 626     return (ret[2], json.JSONDecoder().decode(ret[1]), ret[3])
 627
 628
 629 def do_queryvnf(data, vnfm_id, vnfInstanceId):
 630     logger.debug("[%s] request.data=%s", fun_name(), data)
 631     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 632     logger.debug("[do_deletevnf] vnfm_info=[%s]", vnfm_info)
 633     ret = call_vnfm("api/vnflcm/v1/vnf_instances/%s" % vnfInstanceId, "GET", vnfm_info)
 634     if ret[0] != 0:
 635         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 636         raise GvnfmDriverException('Failed to query vnf.')
 637     return json.JSONDecoder().decode(ret[1])
 638
 639
 640 def do_subscription(data, vnfm_id):
 641     logger.debug("[%s] request.data=%s", fun_name(), data)
 642     vnfm_info = get_vnfminfo_from_nslcm(vnfm_id)
 643     logger.debug("[do_subscription] vnfm_info=[%s]", vnfm_info)
 644     ret = call_vnfm("api/vnflcm/v1/subscriptions", "POST", vnfm_info, data)
 645     logger.debug("[%s] call_req ret=%s", fun_name(), ret)
 646     if ret[0] != 0:
 647         logger.error("Status code is %s, detail is %s.", ret[2], ret[1])
 648         raise GvnfmDriverException('Failed to subscribe.')
 649     return json.JSONDecoder().decode(ret[1])