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