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
  43 logger = logging.getLogger(__name__)
  44
  45
  46 class NfView(APIView):
  47     @swagger_auto_schema(
  48         request_body=InstVnfReqSerializer(),
  49         responses={
  50             status.HTTP_202_ACCEPTED: InstVnfRespSerializer()
  51         }
  52     )
  53     def post(self, request):
  54         logger.debug("VnfCreateView--post::> %s" % request.data)
  55
  56         req_serializer = InstVnfReqSerializer(data=request.data)
  57         if not req_serializer.is_valid():
  58             logger.error(req_serializer.errors)
  59
  60         data = {'ns_instance_id': ignore_case_get(request.data, 'nsInstanceId'),
  61                 'additional_param_for_ns': ignore_case_get(request.data, 'additionalParamForVnf'),
  62                 'additional_param_for_vnf': ignore_case_get(request.data, 'additionalParamForVnf'),
  63                 'vnf_index': ignore_case_get(request.data, 'vnfIndex')}
  64         nf_inst_id, job_id = create_vnfs.prepare_create_params()
  65         CreateVnfs(data, nf_inst_id, job_id).start()
  66         rsp = {
  67             "vnfInstId": nf_inst_id,
  68             "jobId": job_id}
  69
  70         resp_serializer = InstVnfRespSerializer(data=rsp)
  71         if not resp_serializer.is_valid():
  72             logger.error(resp_serializer.errors)
  73
  74         return Response(data=rsp, status=status.HTTP_202_ACCEPTED)
  75
  76
  77 class NfDetailView(APIView):
  78     @swagger_auto_schema(
  79         request_body=None,
  80         responses={
  81             status.HTTP_200_OK: GetVnfRespSerializer(),
  82             status.HTTP_404_NOT_FOUND: "VNF not found"
  83         }
  84     )
  85     def get(self, request, vnfinstid):
  86         logger.debug("VnfQueryView--get::> %s" % vnfinstid)
  87         nf_inst_info = GetVnf(vnfinstid).do_biz()
  88         if not nf_inst_info:
  89             return Response(status=status.HTTP_404_NOT_FOUND)
  90
  91         rsp = {
  92             'vnfInstId': nf_inst_info[0].nfinstid,
  93             'vnfName': nf_inst_info[0].nf_name,
  94             'vnfStatus': nf_inst_info[0].status
  95         }
  96         resp_serializer = GetVnfRespSerializer(data=rsp)
  97         if not resp_serializer.is_valid():
  98             logger.error(resp_serializer.errors)
  99
 100         return Response(status=status.HTTP_200_OK, data=rsp)
 101
 102     @swagger_auto_schema(
 103         request_body=TerminateVnfReqSerializer(),
 104         responses={
 105             status.HTTP_200_OK: TerminateVnfRespSerializer(),
 106             status.HTTP_409_CONFLICT: "Inner error"
 107         }
 108     )
 109     def post(self, request_paras, vnfinstid):
 110         logger.debug("VnfTerminateView--post::> %s, %s", vnfinstid, request_paras.data)
 111
 112         req_serializer = TerminateVnfReqSerializer(data=request_paras.data)
 113         if not req_serializer.is_valid():
 114             logger.error(req_serializer.errors)
 115
 116         vnf_inst_id = vnfinstid
 117         terminationType = ignore_case_get(request_paras.data, 'terminationType')
 118         gracefulTerminationTimeout = ignore_case_get(request_paras.data, 'gracefulTerminationTimeout')
 119         job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF, vnf_inst_id)
 120         data = {'terminationType': terminationType, 'gracefulTerminationTimeout': gracefulTerminationTimeout}
 121         logger.debug("data=%s", data)
 122         try:
 123             TerminateVnfs(data, vnf_inst_id, job_id).start()
 124         except Exception as e:
 125             logger.error(e.message)
 126             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 127         rsp = {'jobId': job_id}
 128
 129         resp_serializer = TerminateVnfRespSerializer(data=rsp)
 130         if not resp_serializer.is_valid():
 131             logger.error(resp_serializer.errors)
 132
 133         return Response(data=rsp, status=status.HTTP_201_CREATED)
 134
 135
 136 class NfGrant(APIView):
 137     @swagger_auto_schema(
 138         request_body=GrantVnfReqSerializer(),
 139         responses={
 140             status.HTTP_201_CREATED: GrantVnfRespSerializer(),
 141             status.HTTP_409_CONFLICT: "Inner error"
 142         }
 143     )
 144     def post(self, request):
 145         logger.debug("NfGrant--post::> %s" % request.data)
 146         try:
 147             req_serializer = GrantVnfReqSerializer(data=request.data)
 148             if not req_serializer.is_valid():
 149                 raise Exception(req_serializer.errors)
 150
 151             vnf_inst_id = ignore_case_get(request.data, 'vnfInstanceId')
 152             job_id = JobUtil.create_job("VNF", JOB_TYPE.GRANT_VNF, vnf_inst_id)
 153             rsp = GrantVnfs(request.data, job_id).send_grant_vnf_to_resMgr()
 154             """
 155             rsp = {
 156                 "vim": {
 157                     "vimid": ignore_case_get(ignore_case_get(request.data, 'additionalparam'), 'vimid'),
 158                     "accessinfo": {
 159                         "tenant": "admin"
 160                     }
 161                 }
 162             }
 163             """
 164             resp_serializer = GrantVnfRespSerializer(data=rsp)
 165             if not resp_serializer.is_valid():
 166                 raise Exception(resp_serializer.errors)
 167
 168             return Response(data=rsp, status=status.HTTP_201_CREATED)
 169         except Exception as e:
 170             logger.error(e.message)
 171             logger.error(traceback.format_exc())
 172             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 173
 174
 175 class LcmNotify(APIView):
 176     def post(self, request_paras, vnfmid, vnfInstanceId):
 177         logger.debug("LcmNotify--post::> %s" % request_paras.data)
 178         try:
 179             NotifyLcm(vnfmid, vnfInstanceId, request_paras.data).do_biz()
 180             return Response(data={}, status=status.HTTP_201_CREATED)
 181         except Exception as e:
 182             logger.error(e.message)
 183             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 184
 185
 186 class NfScaleView(APIView):
 187     def post(self, request_paras, vnfinstid):
 188         logger.debug("NfScaleView--post::> %s" % request_paras.data)
 189         try:
 190             NFManualScaleService(vnfinstid, request_paras.data).start()
 191             return Response(data={}, status=status.HTTP_202_ACCEPTED)
 192         except Exception as e:
 193             logger.error(e.message)
 194             return Response(data={'error': '%s' % e.message}, status=status.HTTP_409_CONFLICT)
 195
 196
 197 class NfVerifyView(APIView):
 198     def post(self, request):
 199         job_id = "VNFSDK_" + str(uuid.uuid4())
 200         logger.debug("NfVerifyView--post::%s> %s", job_id, request.data)
 201         VerifyVnfs(request.data, job_id).start()
 202         return Response(data={"jobId": job_id}, status=status.HTTP_202_ACCEPTED)
 203
 204
 205 class NfVnfmInfoView(APIView):
 206     def get(self, request, vnfmid):
 207         logger.debug("NfVnfmInfoView--get::> %s" % vnfmid)
 208         try:
 209             vnfm_info = get_vnfm_by_id(vnfmid)
 210         except NSLCMException as e:
 211             logger.error(e.message)
 212             return Response(data={'error': '%s' % e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 213         except Exception as e:
 214             logger.error(e.message)
 215             logger.error(traceback.format_exc())
 216             return Response(data={'error': 'Failed to get vnfm info.'},
 217                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 218         return Response(data=vnfm_info, status=status.HTTP_200_OK)
 219
 220
 221 class NfVimInfoView(APIView):
 222     def get(self, request, vimid):
 223         logger.debug("NfVimInfoView--get::> %s" % vimid)
 224         try:
 225             vim_info = get_vim_by_id(vimid)
 226         except NSLCMException as e:
 227             logger.error(e.message)
 228             return Response(data={'error': '%s' % e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 229         except Exception as e:
 230             logger.error(e.message)
 231             logger.error(traceback.format_exc())
 232             return Response(data={'error': 'Failed to get vim info.'},
 233                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 234         return Response(data=vim_info, status=status.HTTP_200_OK)