lcm/ns_vnfs/views/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 import logging
  15 import traceback
  16 import uuid
  17
  18 from drf_yasg.utils import swagger_auto_schema
  19 from rest_framework import status
  20 from rest_framework.response import Response
  21 from rest_framework.views import APIView
  22
  23 from lcm.pub.exceptions import NSLCMException
  24 from lcm.pub.msapi.extsys import get_vnfm_by_id, get_vim_by_id_vim_info
  25 from lcm.pub.utils.jobutil import JobUtil
  26 from lcm.pub.enum import JOB_TYPE
  27 from lcm.pub.utils.values import ignore_case_get
  28 from lcm.ns_vnfs.biz.create_vnfs import CreateVnfs
  29 from lcm.ns_vnfs.biz.get_vnfs import GetVnf, GetVnfVms
  30 from lcm.ns_vnfs.serializers.serializers import GetVnfRespSerializer
  31 from lcm.ns_vnfs.serializers.serializers import GrantVnfReqSerializer
  32 from lcm.ns_vnfs.serializers.serializers import GrantVnfRespSerializer
  33 from lcm.ns_vnfs.biz.grant_vnfs import GrantVnfs
  34 from lcm.ns_vnfs.serializers.serializers import InstVnfReqSerializer
  35 from lcm.ns_vnfs.serializers.serializers import InstVnfRespSerializer
  36 from lcm.ns_vnfs.biz.scale_vnfs import NFManualScaleService
  37 from lcm.ns_vnfs.biz.notify_lcm import NotifyLcm
  38 from lcm.ns_vnfs.serializers.serializers import NotifyLcmReqSerializer
  39 from lcm.ns_vnfs.serializers.serializers import PlaceVnfReqSerializer
  40 from lcm.ns_vnfs.biz.place_vnfs import PlaceVnfs
  41 from lcm.ns_vnfs.serializers.serializers import ScaleVnfReqSerializer
  42 from lcm.ns_vnfs.serializers.serializers import ScaleVnfRespSerializer
  43 from lcm.ns_vnfs.serializers.serializers import TerminateVnfReqSerializer
  44 from lcm.ns_vnfs.serializers.serializers import TerminateVnfRespSerializer
  45 from lcm.ns_vnfs.biz.terminate_nfs import TerminateVnfs
  46 from lcm.ns_vnfs.serializers.serializers import VerifyVnfReqSerializer
  47 from lcm.ns_vnfs.serializers.serializers import VerifyVnfRespSerializer
  48 from lcm.ns_vnfs.biz.verify_vnfs import VerifyVnfs
  49 from lcm.ns_vnfs.serializers.serializers import VimInfoRespSerializer
  50 from lcm.ns_vnfs.serializers.serializers import VnfmInfoRespSerializer
  51 from lcm.ns_vnfs.biz import create_vnfs
  52
  53 logger = logging.getLogger(__name__)
  54
  55
  56 class NfView(APIView):
  57     @swagger_auto_schema(
  58         request_body=InstVnfReqSerializer(),
  59         responses={
  60             status.HTTP_202_ACCEPTED: InstVnfRespSerializer()
  61         }
  62     )
  63     def post(self, request):
  64         logger.debug("VnfCreateView--post::> %s" % request.data)
  65
  66         req_serializer = InstVnfReqSerializer(data=request.data)
  67         if not req_serializer.is_valid():
  68             logger.error(req_serializer.errors)
  69
  70         data = {'ns_instance_id': ignore_case_get(request.data, 'nsInstanceId'),
  71                 'additional_param_for_vnf': ignore_case_get(request.data, 'additionalParamForVnf'),
  72                 'vnf_index': ignore_case_get(request.data, 'vnfIndex')}
  73         nf_inst_id, job_id = create_vnfs.prepare_create_params()
  74         CreateVnfs(data, nf_inst_id, job_id).start()
  75         rsp = {
  76             "vnfInstId": nf_inst_id,
  77             "jobId": job_id}
  78
  79         resp_serializer = InstVnfRespSerializer(data=rsp)
  80         if not resp_serializer.is_valid():
  81             logger.error(resp_serializer.errors)
  82
  83         return Response(data=rsp, status=status.HTTP_202_ACCEPTED)
  84
  85
  86 class NfDetailView(APIView):
  87     @swagger_auto_schema(
  88         request_body=None,
  89         responses={
  90             status.HTTP_200_OK: GetVnfRespSerializer(),
  91             status.HTTP_404_NOT_FOUND: "VNF not found"
  92         }
  93     )
  94     def get(self, request, vnfinstid):
  95         logger.debug("VnfQueryView--get::> %s" % vnfinstid)
  96         nf_inst_info = GetVnf(vnfinstid).do_biz()
  97         if not nf_inst_info:
  98             return Response(status=status.HTTP_404_NOT_FOUND)
  99
 100         vnf_vms = GetVnfVms(vnfinstid).do_biz()
 101
 102         rsp = {
 103             'vnfInstId': nf_inst_info[0].nfinstid,
 104             'vnfName': nf_inst_info[0].nf_name,
 105             'vnfStatus': nf_inst_info[0].status,
 106             'vnfVms': [{
 107                 'vmId': vm.vmid,
 108                 'vmName': vm.vmname
 109             } for vm in vnf_vms]
 110         }
 111         resp_serializer = GetVnfRespSerializer(data=rsp)
 112         if not resp_serializer.is_valid():
 113             logger.error(resp_serializer.errors)
 114
 115         return Response(status=status.HTTP_200_OK, data=rsp)
 116
 117
 118 class NfTerminate(APIView):
 119     @swagger_auto_schema(
 120         request_body=TerminateVnfReqSerializer(),
 121         responses={
 122             status.HTTP_202_ACCEPTED: TerminateVnfRespSerializer(),
 123             status.HTTP_409_CONFLICT: "Inner error"
 124         }
 125     )
 126     def post(self, request, vnfinstid):
 127         logger.debug("NfTerminate--post::> %s, %s", vnfinstid, request.data)
 128
 129         req_serializer = TerminateVnfReqSerializer(data=request.data)
 130         if not req_serializer.is_valid():
 131             logger.error(req_serializer.errors)
 132
 133         vnf_inst_id = vnfinstid
 134         terminationType = ignore_case_get(request.data, 'terminationType')
 135         gracefulTerminationTimeout = ignore_case_get(request.data, 'gracefulTerminationTimeout')
 136         job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF, vnf_inst_id)
 137         data = {'terminationType': terminationType, 'gracefulTerminationTimeout': gracefulTerminationTimeout}
 138         logger.debug("data=%s", data)
 139         try:
 140             TerminateVnfs(data, vnf_inst_id, job_id).start()
 141         except Exception as e:
 142             logger.error(e.message)
 143             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 144         rsp = {'jobId': job_id}
 145
 146         resp_serializer = TerminateVnfRespSerializer(data=rsp)
 147         if not resp_serializer.is_valid():
 148             logger.error(resp_serializer.errors)
 149
 150         return Response(data=rsp, status=status.HTTP_202_ACCEPTED)
 151
 152
 153 class NfGrant(APIView):
 154     @swagger_auto_schema(
 155         request_body=GrantVnfReqSerializer(),
 156         responses={
 157             status.HTTP_201_CREATED: GrantVnfRespSerializer(),
 158             status.HTTP_409_CONFLICT: "Inner error"
 159         }
 160     )
 161     def post(self, request):
 162         logger.debug("NfGrant--post::> %s" % request.data)
 163         try:
 164             req_serializer = GrantVnfReqSerializer(data=request.data)
 165             if not req_serializer.is_valid():
 166                 raise Exception(req_serializer.errors)
 167
 168             vnf_inst_id = ignore_case_get(request.data, 'vnfInstanceId')
 169             job_id = JobUtil.create_job("VNF", JOB_TYPE.GRANT_VNF, vnf_inst_id)
 170             rsp = GrantVnfs(request.data, job_id).send_grant_vnf_to_resMgr()
 171             """
 172             rsp = {
 173                 "vim": {
 174                     "vimid": ignore_case_get(ignore_case_get(request.data, 'additionalparam'), 'vimid'),
 175                     "accessinfo": {
 176                         "tenant": "admin"
 177                     }
 178                 }
 179             }
 180             """
 181             # resp_serializer = GrantVnfRespSerializer(data=rsp)
 182             # if not resp_serializer.is_valid():
 183             # raise Exception(resp_serializer.errors)
 184
 185             return Response(data=rsp, status=status.HTTP_201_CREATED)
 186         except Exception as e:
 187             logger.error(e.message)
 188             logger.error(traceback.format_exc())
 189             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 190
 191
 192 class NfPlacement(APIView):
 193     @swagger_auto_schema(
 194         request_body=PlaceVnfReqSerializer(),
 195         response={
 196             status.HTTP_201_CREATED: PlaceVnfReqSerializer(),
 197             status.HTTP_404_NOT_FOUND: "Placement not found"
 198         }
 199     )
 200     def post(self, request):
 201         logger.debug("NfPlacement--post::> %s" % request.data)
 202         try:
 203             req_serializer = PlaceVnfReqSerializer(data=request.data)
 204             if not req_serializer.is_valid():
 205                 raise Exception(req_serializer.errors)
 206             PlaceVnfs(request.data).extract()
 207             return Response(data={}, status=status.HTTP_200_OK)
 208         except Exception as e:
 209             logger.error(e.message)
 210             logger.error(traceback.format_exc())
 211             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 212
 213
 214 class LcmNotify(APIView):
 215     @swagger_auto_schema(
 216         request_body=NotifyLcmReqSerializer(),
 217         responses={
 218             status.HTTP_201_CREATED: 'successful',
 219             status.HTTP_409_CONFLICT: "Inner error"
 220         }
 221     )
 222     def post(self, request, vnfmid, vnfInstanceId):
 223         logger.debug("LcmNotify--post::> %s" % request.data)
 224         try:
 225             req_serializer = NotifyLcmReqSerializer(data=request.data)
 226             if not req_serializer.is_valid():
 227                 raise Exception(req_serializer.errors)
 228
 229             NotifyLcm(vnfmid, vnfInstanceId, request.data).do_biz()
 230             return Response(data={}, status=status.HTTP_201_CREATED)
 231         except Exception as e:
 232             logger.error(e.message)
 233             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 234
 235
 236 class NfScaleView(APIView):
 237     @swagger_auto_schema(
 238         request_body=ScaleVnfReqSerializer(),
 239         responses={
 240             status.HTTP_202_ACCEPTED: ScaleVnfRespSerializer(),
 241             status.HTTP_409_CONFLICT: "Inner error"
 242         }
 243     )
 244     def post(self, request, vnfinstid):
 245         logger.debug("NfScaleView--post::> %s" % request.data)
 246         try:
 247             req_serializer = ScaleVnfReqSerializer(data=request.data)
 248             if not req_serializer.is_valid():
 249                 raise Exception(req_serializer.errors)
 250             NFManualScaleService(vnfinstid, request.data).start()
 251             return Response(data={}, status=status.HTTP_202_ACCEPTED)
 252         except Exception as e:
 253             logger.error(e.message)
 254             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 255
 256
 257 class NfVerifyView(APIView):
 258     @swagger_auto_schema(
 259         request_body=VerifyVnfReqSerializer(),
 260         responses={
 261             status.HTTP_202_ACCEPTED: VerifyVnfRespSerializer(),
 262             status.HTTP_409_CONFLICT: "Inner error"
 263         }
 264     )
 265     def post(self, request):
 266         job_id = "VNFSDK_" + str(uuid.uuid4())
 267         logger.debug("NfVerifyView--post::%s> %s", job_id, request.data)
 268         try:
 269             req_serializer = VerifyVnfReqSerializer(data=request.data)
 270             if not req_serializer.is_valid():
 271                 raise Exception(req_serializer.errors)
 272
 273             VerifyVnfs(request.data, job_id).start()
 274
 275             rsp = {"jobId": job_id}
 276             resp_serializer = VerifyVnfRespSerializer(data=rsp)
 277             if not resp_serializer.is_valid():
 278                 raise Exception(resp_serializer.errors)
 279
 280             return Response(data=rsp, status=status.HTTP_202_ACCEPTED)
 281         except Exception as e:
 282             logger.error(e.message)
 283             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 284
 285
 286 class NfVnfmInfoView(APIView):
 287     @swagger_auto_schema(
 288         request_body=None,
 289         responses={
 290             status.HTTP_200_OK: VnfmInfoRespSerializer(),
 291             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 292         }
 293     )
 294     def get(self, request, vnfmid):
 295         logger.debug("NfVnfmInfoView--get::> %s" % vnfmid)
 296         try:
 297             vnfm_info = get_vnfm_by_id(vnfmid)
 298
 299             resp_serializer = VnfmInfoRespSerializer(data=vnfm_info)
 300             if not resp_serializer.is_valid():
 301                 raise Exception(resp_serializer.errors)
 302
 303         except NSLCMException as e:
 304             logger.error(e.message)
 305             return Response(data={'error': '%s' % e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 306         except Exception as e:
 307             logger.error(e.message)
 308             logger.error(traceback.format_exc())
 309             return Response(data={'error': 'Failed to get vnfm info.'},
 310                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 311         return Response(data=vnfm_info, status=status.HTTP_200_OK)
 312
 313
 314 class NfVimInfoView(APIView):
 315     @swagger_auto_schema(
 316         request_body=None,
 317         responses={
 318             status.HTTP_200_OK: VimInfoRespSerializer(),
 319             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 320         }
 321     )
 322     # def get(self, request, vimid):
 323     def get(self, request, cloudowner, cloudregionid):
 324         logger.debug("NfVimInfoView--get::> %s,%s" % (cloudowner, cloudregionid))
 325         try:
 326             # vim_info = get_vim_by_id(vimid)
 327             vim_info = get_vim_by_id_vim_info(cloudowner, cloudregionid)
 328
 329             resp_serializer = VimInfoRespSerializer(data=vim_info)
 330             if not resp_serializer.is_valid():
 331                 raise Exception(resp_serializer.errors)
 332
 333         except NSLCMException as e:
 334             logger.error(e.message)
 335             return Response(data={'error': '%s' % e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 336         except Exception as e:
 337             logger.error(e.message)
 338             logger.error(traceback.format_exc())
 339             return Response(data={'error': 'Failed to get vim info.'},
 340                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 341         return Response(data=vim_info, status=status.HTTP_200_OK)