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