lcm/ns/vnfs/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 rest_framework import status
  19 from rest_framework.response import Response
  20 from rest_framework.views import APIView
  21 from drf_yasg.utils import swagger_auto_schema
  22
  23 from lcm.ns.vnfs import create_vnfs
  24 from lcm.ns.vnfs.create_vnfs import CreateVnfs
  25 from lcm.ns.vnfs.verify_vnfs import VerifyVnfs
  26 from lcm.ns.vnfs.get_vnfs import GetVnf
  27 from lcm.ns.vnfs.scale_vnfs import NFManualScaleService
  28 from lcm.ns.vnfs.terminate_nfs import TerminateVnfs
  29 from lcm.ns.vnfs.grant_vnfs import GrantVnfs
  30 from lcm.ns.vnfs.place_vnfs import PlaceVnfs
  31 from lcm.ns.vnfs.notify_lcm import NotifyLcm
  32 from lcm.pub.exceptions import NSLCMException
  33 from lcm.pub.msapi.extsys import get_vnfm_by_id, get_vim_by_id
  34 from lcm.pub.utils.jobutil import JobUtil, JOB_TYPE
  35 from lcm.pub.utils.values import ignore_case_get
  36 from lcm.ns.vnfs.serializers import InstVnfReqSerializer
  37 from lcm.ns.vnfs.serializers import InstVnfRespSerializer
  38 from lcm.ns.vnfs.serializers import GetVnfRespSerializer
  39 from lcm.ns.vnfs.serializers import TerminateVnfReqSerializer
  40 from lcm.ns.vnfs.serializers import TerminateVnfRespSerializer
  41 from lcm.ns.vnfs.serializers import GrantVnfReqSerializer
  42 from lcm.ns.vnfs.serializers import GrantVnfRespSerializer
  43 from lcm.ns.vnfs.serializers import NotifyLcmReqSerializer
  44 from lcm.ns.vnfs.serializers import ScaleVnfReqSerializer
  45 from lcm.ns.vnfs.serializers import ScaleVnfRespSerializer
  46 from lcm.ns.vnfs.serializers import VerifyVnfReqSerializer
  47 from lcm.ns.vnfs.serializers import VerifyVnfRespSerializer
  48 from lcm.ns.vnfs.serializers import VnfmInfoRespSerializer
  49 from lcm.ns.vnfs.serializers import VimInfoRespSerializer
  50 from lcm.ns.vnfs.serializers import PlaceVnfReqSerializer
  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)