mgr/mgr/vnfreg/views.py

   1 # Copyright 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
  15 import logging
  16 import json
  17 import traceback
  18
  19 from drf_yasg import openapi
  20 from drf_yasg.utils import swagger_auto_schema
  21 from rest_framework import status
  22 from rest_framework.decorators import api_view
  23 from rest_framework.response import Response
  24 from rest_framework.views import APIView
  25
  26 from mgr.pub.utils.values import ignore_case_get
  27 from mgr.pub.utils.syscomm import fun_name
  28 from mgr.pub.database.models import VnfRegModel
  29 from mgr.pub.utils import restcall
  30 from mgr.vnfreg.serializers import ErrorSerializer, VnfInfoSerializer, ResponseSerializer, NoneSerializer
  31
  32 logger = logging.getLogger(__name__)
  33
  34
  35 def handler_exception(e):
  36     logger.error(e.message)
  37     logger.error(traceback.format_exc())
  38     errorSerializer = ErrorSerializer(data={'error': e.message})
  39     errorSerializer.is_valid()
  40     return errorSerializer.data
  41
  42
  43 class vnfmgr_addvnf(APIView):
  44     @swagger_auto_schema(request_body=VnfInfoSerializer(),
  45                          responses={
  46                              201: ResponseSerializer(),
  47                              500: ErrorSerializer()})
  48     def post(self, request):
  49         logger.info("Enter %s, data is %s", fun_name(), request.data)
  50         requestSerializer = VnfInfoSerializer(data=request.data)
  51         request_isValid = requestSerializer.is_valid()
  52         try:
  53             if not request_isValid:
  54                 raise Exception(requestSerializer.errors)
  55
  56             requestData = requestSerializer.data
  57             vnf_inst_id = ignore_case_get(requestData, "vnfInstId")
  58             if VnfRegModel.objects.filter(id=vnf_inst_id):
  59                 raise Exception("Vnf(%s) already exists." % vnf_inst_id)
  60             VnfRegModel(
  61                 id=vnf_inst_id,
  62                 ip=ignore_case_get(requestData, "ip"),
  63                 port=ignore_case_get(requestData, "port"),
  64                 username=ignore_case_get(requestData, "username"),
  65                 password=ignore_case_get(requestData, "password")).save()
  66
  67             responseSerializer = ResponseSerializer(data={"vnfInstId": vnf_inst_id})
  68             isValid = responseSerializer.is_valid()
  69             if not isValid:
  70                 raise Exception(responseSerializer.errors)
  71         except Exception as e:
  72             errorData = handler_exception(e)
  73             return Response(data=errorData, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  74
  75         return Response(data=responseSerializer.data, status=status.HTTP_201_CREATED)
  76
  77
  78 @swagger_auto_schema(method='put',
  79                      request_body=VnfInfoSerializer(),
  80                      responses={
  81                          202: NoneSerializer(),
  82                          500: ErrorSerializer()})
  83 @swagger_auto_schema(method='delete',
  84                      responses={
  85                          204: NoneSerializer(),
  86                          500: ErrorSerializer()})
  87 @swagger_auto_schema(methods=['get'],
  88                      manual_parameters=[
  89                          openapi.Parameter('test',
  90                                            openapi.IN_QUERY,
  91                                            "test manual param",
  92                                            type=openapi.TYPE_BOOLEAN
  93                                            ), ],
  94                      responses={
  95                          200: openapi.Response('response description', VnfInfoSerializer()),
  96                          500: ErrorSerializer()})
  97 @api_view(http_method_names=['GET', 'PUT', 'DELETE'])
  98 def access_vnf(request, *args, **kwargs):
  99     requestSerializer = VnfInfoSerializer(data=request.data)
 100     request_isValid = requestSerializer.is_valid()
 101     vnf_inst_id = ignore_case_get(kwargs, "vnfInstId")
 102     logger.info("Enter %s, method is %s, ", fun_name(), request.method)
 103     logger.info("vnfInstId is %s, data is %s", vnf_inst_id, request.data)
 104     try:
 105         vnf = VnfRegModel.objects.filter(id=vnf_inst_id)
 106         if not vnf:
 107             err_msg = "Vnf(%s) does not exist." % vnf_inst_id
 108             return Response(data={'error': err_msg}, status=status.HTTP_404_NOT_FOUND)
 109         if request.method == 'GET':
 110             resp = {
 111                 "vnfInstId": vnf_inst_id,
 112                 "ip": vnf[0].ip,
 113                 "port": vnf[0].port,
 114                 "username": vnf[0].username,
 115                 "password": vnf[0].password
 116             }
 117             responseSerializer = VnfInfoSerializer(data=resp)
 118             if not responseSerializer.is_valid():
 119                 raise Exception(responseSerializer.errors)
 120             ret = responseSerializer.data
 121             normal_status = status.HTTP_200_OK
 122         elif request.method == 'PUT':
 123             if not request_isValid:
 124                 raise Exception(requestSerializer.errors)
 125
 126             requestData = requestSerializer.data
 127             ip = ignore_case_get(requestData, "ip")
 128             port = ignore_case_get(requestData, "port")
 129             username = ignore_case_get(requestData, "username")
 130             password = ignore_case_get(requestData, "password")
 131             if ip:
 132                 vnf[0].ip = ip
 133             if port:
 134                 vnf[0].port = port
 135             if username:
 136                 vnf[0].username = username
 137             if password:
 138                 vnf[0].password = password
 139             vnf[0].save()
 140             ret = {}
 141             normal_status = status.HTTP_202_ACCEPTED
 142         else:
 143             vnf.delete()
 144             ret = {}
 145             normal_status = status.HTTP_204_NO_CONTENT
 146     except Exception as e:
 147         errorData = handler_exception(e)
 148         return Response(data=errorData, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 149     return Response(data=ret, status=normal_status)
 150
 151
 152 @api_view(http_method_names=['POST'])
 153 def vnf_config(request, *args, **kwargs):
 154     logger.info("Enter %s, data is %s", fun_name(), request.data)
 155     vnf_inst_id = ignore_case_get(request.data, "vnfInstanceId")
 156     try:
 157         vnf = VnfRegModel.objects.filter(id=vnf_inst_id)
 158         if not vnf:
 159             raise Exception("Vnf(%s) does not exist." % vnf_inst_id)
 160         ret = restcall.call_req(
 161             base_url="http://%s:%s/" % (vnf[0].ip, vnf[0].port),
 162             user=vnf[0].username,
 163             passwd=vnf[0].password,
 164             auth_type=restcall.rest_no_auth,
 165             resource="v1/vnfconfig",
 166             method="POST",
 167             content=json.dumps(request.data))
 168         if ret[0] != 0:
 169             raise Exception("Failed to config Vnf(%s): %s" % (vnf_inst_id, ret[1]))
 170     except Exception as e:
 171         logger.error(e.message)
 172         logger.error(traceback.format_exc())
 173         return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 174     return Response(data={}, status=status.HTTP_202_ACCEPTED)