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
  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
  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_ns': ignore_case_get(request.data, 'additionalParamForVnf'),
  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         rsp = {
 101             'vnfInstId': nf_inst_info[0].nfinstid,
 102             'vnfName': nf_inst_info[0].nf_name,
 103             'vnfStatus': nf_inst_info[0].status
 104         }
 105         resp_serializer = GetVnfRespSerializer(data=rsp)
 106         if not resp_serializer.is_valid():
 107             logger.error(resp_serializer.errors)
 108
 109         return Response(status=status.HTTP_200_OK, data=rsp)
 110
 111     @swagger_auto_schema(
 112         request_body=TerminateVnfReqSerializer(),
 113         responses={
 114             status.HTTP_200_OK: TerminateVnfRespSerializer(),
 115             status.HTTP_409_CONFLICT: "Inner error"
 116         }
 117     )
 118     def post(self, request_paras, vnfinstid):
 119         logger.debug("VnfTerminateView--post::> %s, %s", vnfinstid, request_paras.data)
 120
 121         req_serializer = TerminateVnfReqSerializer(data=request_paras.data)
 122         if not req_serializer.is_valid():
 123             logger.error(req_serializer.errors)
 124
 125         vnf_inst_id = vnfinstid
 126         terminationType = ignore_case_get(request_paras.data, 'terminationType')
 127         gracefulTerminationTimeout = ignore_case_get(request_paras.data, 'gracefulTerminationTimeout')
 128         job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF, vnf_inst_id)
 129         data = {'terminationType': terminationType, 'gracefulTerminationTimeout': gracefulTerminationTimeout}
 130         logger.debug("data=%s", data)
 131         try:
 132             TerminateVnfs(data, vnf_inst_id, job_id).start()
 133         except Exception as e:
 134             logger.error(e.message)
 135             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 136         rsp = {'jobId': job_id}
 137
 138         resp_serializer = TerminateVnfRespSerializer(data=rsp)
 139         if not resp_serializer.is_valid():
 140             logger.error(resp_serializer.errors)
 141
 142         return Response(data=rsp, status=status.HTTP_201_CREATED)
 143
 144
 145 class NfGrant(APIView):
 146     @swagger_auto_schema(
 147         request_body=GrantVnfReqSerializer(),
 148         responses={
 149             status.HTTP_201_CREATED: GrantVnfRespSerializer(),
 150             status.HTTP_409_CONFLICT: "Inner error"
 151         }
 152     )
 153     def post(self, request):
 154         logger.debug("NfGrant--post::> %s" % request.data)
 155         try:
 156             req_serializer = GrantVnfReqSerializer(data=request.data)
 157             if not req_serializer.is_valid():
 158                 raise Exception(req_serializer.errors)
 159
 160             vnf_inst_id = ignore_case_get(request.data, 'vnfInstanceId')
 161             job_id = JobUtil.create_job("VNF", JOB_TYPE.GRANT_VNF, vnf_inst_id)
 162             rsp = GrantVnfs(request.data, job_id).send_grant_vnf_to_resMgr()
 163             """
 164             rsp = {
 165                 "vim": {
 166                     "vimid": ignore_case_get(ignore_case_get(request.data, 'additionalparam'), 'vimid'),
 167                     "accessinfo": {
 168                         "tenant": "admin"
 169                     }
 170                 }
 171             }
 172             """
 173             # resp_serializer = GrantVnfRespSerializer(data=rsp)
 174             # if not resp_serializer.is_valid():
 175             # raise Exception(resp_serializer.errors)
 176
 177             return Response(data=rsp, status=status.HTTP_201_CREATED)
 178         except Exception as e:
 179             logger.error(e.message)
 180             logger.error(traceback.format_exc())
 181             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 182
 183
 184 class NfPlacement(APIView):
 185     @swagger_auto_schema(
 186         request_body=PlaceVnfReqSerializer(),
 187         response={
 188             status.HTTP_201_CREATED: PlaceVnfReqSerializer(),
 189             status.HTTP_404_NOT_FOUND: "Placement not found"
 190         }
 191     )
 192     def post(self, request):
 193         logger.debug("NfPlacement--post::> %s" % request.data)
 194         try:
 195             req_serializer = PlaceVnfReqSerializer(data=request.data)
 196             if not req_serializer.is_valid():
 197                 raise Exception(req_serializer.errors)
 198             PlaceVnfs(request.data).extract()
 199             return Response(data={}, status=status.HTTP_200_OK)
 200         except Exception as e:
 201             logger.error(e.message)
 202             logger.error(traceback.format_exc())
 203             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 204
 205
 206 class LcmNotify(APIView):
 207     @swagger_auto_schema(
 208         request_body=NotifyLcmReqSerializer(),
 209         responses={
 210             status.HTTP_201_CREATED: 'successful',
 211             status.HTTP_409_CONFLICT: "Inner error"
 212         }
 213     )
 214     def post(self, request, vnfmid, vnfInstanceId):
 215         logger.debug("LcmNotify--post::> %s" % request.data)
 216         try:
 217             req_serializer = NotifyLcmReqSerializer(data=request.data)
 218             if not req_serializer.is_valid():
 219                 raise Exception(req_serializer.errors)
 220
 221             NotifyLcm(vnfmid, vnfInstanceId, request.data).do_biz()
 222             return Response(data={}, status=status.HTTP_201_CREATED)
 223         except Exception as e:
 224             logger.error(e.message)
 225             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 226
 227
 228 class NfScaleView(APIView):
 229     @swagger_auto_schema(
 230         request_body=ScaleVnfReqSerializer(),
 231         responses={
 232             status.HTTP_202_ACCEPTED: ScaleVnfRespSerializer(),
 233             status.HTTP_409_CONFLICT: "Inner error"
 234         }
 235     )
 236     def post(self, request, vnfinstid):
 237         logger.debug("NfScaleView--post::> %s" % request.data)
 238         try:
 239             req_serializer = ScaleVnfReqSerializer(data=request.data)
 240             if not req_serializer.is_valid():
 241                 raise Exception(req_serializer.errors)
 242             NFManualScaleService(vnfinstid, request.data).start()
 243             return Response(data={}, status=status.HTTP_202_ACCEPTED)
 244         except Exception as e:
 245             logger.error(e.message)
 246             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 247
 248
 249 class NfVerifyView(APIView):
 250     @swagger_auto_schema(
 251         request_body=VerifyVnfReqSerializer(),
 252         responses={
 253             status.HTTP_202_ACCEPTED: VerifyVnfRespSerializer(),
 254             status.HTTP_409_CONFLICT: "Inner error"
 255         }
 256     )
 257     def post(self, request):
 258         job_id = "VNFSDK_" + str(uuid.uuid4())
 259         logger.debug("NfVerifyView--post::%s> %s", job_id, request.data)
 260         try:
 261             req_serializer = VerifyVnfReqSerializer(data=request.data)
 262             if not req_serializer.is_valid():
 263                 raise Exception(req_serializer.errors)
 264
 265             VerifyVnfs(request.data, job_id).start()
 266
 267             rsp = {"jobId": job_id}
 268             resp_serializer = VerifyVnfRespSerializer(data=rsp)
 269             if not resp_serializer.is_valid():
 270                 raise Exception(resp_serializer.errors)
 271
 272             return Response(data=rsp, status=status.HTTP_202_ACCEPTED)
 273         except Exception as e:
 274             logger.error(e.message)
 275             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 276
 277
 278 class NfVnfmInfoView(APIView):
 279     @swagger_auto_schema(
 280         request_body=None,
 281         responses={
 282             status.HTTP_200_OK: VnfmInfoRespSerializer(),
 283             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 284         }
 285     )
 286     def get(self, request, vnfmid):
 287         logger.debug("NfVnfmInfoView--get::> %s" % vnfmid)
 288         try:
 289             vnfm_info = get_vnfm_by_id(vnfmid)
 290
 291             resp_serializer = VnfmInfoRespSerializer(data=vnfm_info)
 292             if not resp_serializer.is_valid():
 293                 raise Exception(resp_serializer.errors)
 294
 295         except NSLCMException as e:
 296             logger.error(e.message)
 297             return Response(data={'error': '%s' % e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 298         except Exception as e:
 299             logger.error(e.message)
 300             logger.error(traceback.format_exc())
 301             return Response(data={'error': 'Failed to get vnfm info.'},
 302                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 303         return Response(data=vnfm_info, status=status.HTTP_200_OK)
 304
 305
 306 class NfVimInfoView(APIView):
 307     @swagger_auto_schema(
 308         request_body=None,
 309         responses={
 310             status.HTTP_200_OK: VimInfoRespSerializer(),
 311             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 312         }
 313     )
 314     def get(self, request, vimid):
 315         logger.debug("NfVimInfoView--get::> %s" % vimid)
 316         try:
 317             vim_info = get_vim_by_id(vimid)
 318
 319             resp_serializer = VimInfoRespSerializer(data=vim_info)
 320             if not resp_serializer.is_valid():
 321                 raise Exception(resp_serializer.errors)
 322
 323         except NSLCMException as e:
 324             logger.error(e.message)
 325             return Response(data={'error': '%s' % e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 326         except Exception as e:
 327             logger.error(e.message)
 328             logger.error(traceback.format_exc())
 329             return Response(data={'error': 'Failed to get vim info.'},
 330                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 331         return Response(data=vim_info, status=status.HTTP_200_OK)