lcm/ns_sfcs/views/views.py

   1 # Copyright 2016 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
  16 import json
  17 import logging
  18 import time
  19 import traceback
  20 import uuid
  21
  22 from drf_yasg.utils import swagger_auto_schema
  23 from lcm.ns_sfcs.biz.create_flowcla import CreateFlowClassifier
  24 from lcm.ns_sfcs.biz.create_port_chain import CreatePortChain
  25 from lcm.ns_sfcs.biz.create_portpairgp import CreatePortPairGroup
  26 from lcm.ns_sfcs.biz.create_sfc_worker import CreateSfcWorker
  27 from lcm.ns_sfcs.serializers.serializers import CreateFlowClaSerializer
  28 from lcm.ns_sfcs.serializers.serializers import CreatePortChainSerializer
  29 from lcm.ns_sfcs.serializers.serializers import CreatePortPairGpSerializer
  30 from lcm.ns_sfcs.serializers.serializers import CreateSfcInstReqSerializer, CreateSfcInstRespSerializer
  31 from lcm.ns_sfcs.serializers.serializers import CreateSfcReqSerializer, CreateSfcRespSerializer
  32 from lcm.ns_sfcs.biz.sfc_instance import SfcInstance
  33 from rest_framework import status
  34 from rest_framework.response import Response
  35 from rest_framework.views import APIView
  36
  37 from lcm.ns_sfcs.biz.utils import get_fp_id, ignorcase_get
  38
  39 logger = logging.getLogger(__name__)
  40
  41
  42 class SfcInstanceView(APIView):
  43     @swagger_auto_schema(
  44         request_body=CreateSfcInstReqSerializer(),
  45         responses={
  46             status.HTTP_200_OK: CreateSfcInstRespSerializer(),
  47             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
  48         }
  49     )
  50     def post(self, request):
  51         try:
  52             req_serializer = CreateSfcInstReqSerializer(data=request.data)
  53             if not req_serializer.is_valid():
  54                 raise Exception(req_serializer.errors)
  55
  56             data = {
  57                 'nsinstid': request.data['nsInstanceId'],
  58                 "ns_model_data": json.loads(request.data['context']),
  59                 'fpindex': request.data['fpindex'],
  60                 'fpinstid': str(uuid.uuid4()),
  61                 'sdncontrollerid': request.data["sdnControllerId"]}
  62             rsp = SfcInstance(data).do_biz()
  63
  64             resp_serializer = CreateSfcInstRespSerializer(data=rsp)
  65             if not resp_serializer.is_valid():
  66                 raise Exception(resp_serializer.errors)
  67
  68             return Response(data=rsp, status=status.HTTP_200_OK)
  69         except Exception as e:
  70             logger.error(traceback.format_exc())
  71             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  72
  73
  74 class PortPairGpView(APIView):
  75     @swagger_auto_schema(
  76         request_body=CreatePortPairGpSerializer(),
  77         responses={
  78             status.HTTP_200_OK: 'successful'
  79         }
  80     )
  81     def post(self, request):
  82         req_serializer = CreatePortPairGpSerializer(data=request.data)
  83         if not req_serializer.is_valid():
  84             logger.error(req_serializer.errors)
  85
  86         data = {
  87             'fpinstid': request.data["fpinstid"],
  88             "ns_model_data": json.loads(request.data['context']),
  89             'nsinstid': request.data["nsinstanceid"]}
  90         CreatePortPairGroup(data).do_biz()
  91         return Response(status=status.HTTP_200_OK)
  92
  93
  94 class FlowClaView(APIView):
  95     @swagger_auto_schema(
  96         request_body=CreateFlowClaSerializer(),
  97         responses={
  98             status.HTTP_200_OK: 'successful'
  99         }
 100     )
 101     def post(self, request):
 102         req_serializer = CreateFlowClaSerializer(data=request.data)
 103         if not req_serializer.is_valid():
 104             logger.error(req_serializer.errors)
 105
 106         data = {
 107             'fpinstid': request.data["fpinstid"],
 108             "ns_model_data": json.loads(request.data['context'])}
 109         CreateFlowClassifier(data).do_biz()
 110         return Response(status=status.HTTP_200_OK)
 111
 112
 113 class PortChainView(APIView):
 114     @swagger_auto_schema(
 115         request_body=CreatePortChainSerializer(),
 116         responses={
 117             status.HTTP_200_OK: 'successful'
 118         }
 119     )
 120     def post(self, request):
 121         req_serializer = CreatePortChainSerializer(data=request.data)
 122         if not req_serializer.is_valid():
 123             logger.error(req_serializer.errors)
 124
 125         data = {
 126             'fpinstid': request.data["fpinstid"],
 127             "ns_model_data": json.loads(request.data['context'])}
 128         CreatePortChain(data).do_biz()
 129         return Response(status=status.HTTP_200_OK)
 130
 131
 132 class SfcView(APIView):
 133     @swagger_auto_schema(
 134         request_body=CreateSfcReqSerializer(),
 135         responses={
 136             status.HTTP_200_OK: CreateSfcRespSerializer()
 137         }
 138     )
 139     def post(self, request):
 140         try:
 141             logger.info("Create Service Function Chain start")
 142             logger.info("service_function_chain_request: %s" % json.dumps(request.data))
 143             logger.info("service_function_chain_context  : %s" % json.dumps(request.data['context']))
 144             logger.info("service_function_chain_context  : %s" % request.data['context'])
 145             logger.info("service_function_chain_instanceid : %s" % ignorcase_get(request.data, 'nsInstanceId'))
 146             logger.info("service_function_chain_sdncontrollerid : %s" % ignorcase_get(request.data, 'sdnControllerId'))
 147             logger.info("service_function_chain_fpindex : %s" % ignorcase_get(request.data, 'fpindex'))
 148             ns_model_data = request.data['context']
 149
 150             req_serializer = CreateSfcReqSerializer(data=request.data)
 151             if not req_serializer.is_valid():
 152                 raise Exception(req_serializer.errors)
 153         except Exception as e:
 154             logger.error("Exception occurs: %s", e.message)
 155             logger.error(traceback.format_exc())
 156         data = {
 157             'nsinstid': ignorcase_get(request.data, 'nsInstanceId'),
 158             "ns_model_data": ns_model_data,
 159             'fpindex': get_fp_id(ignorcase_get(request.data, 'fpindex'), ns_model_data),
 160             'fpinstid': str(uuid.uuid4()),
 161             'sdncontrollerid': ignorcase_get(request.data, 'sdnControllerId')
 162         }
 163         logger.info("Save FPInstModel start: ")
 164         SfcInstance(data).do_biz()
 165         logger.info("Save FPInstModel end: ")
 166         worker = CreateSfcWorker(data)
 167         job_id = worker.init_data()
 168         worker.start()
 169         logger.info("Service Function Chain Thread Sleep start : %s" % time.ctime())
 170         time.sleep(2)
 171         logger.info("Service Function Chain Thread Sleep end: %s" % time.ctime())
 172         logger.info("Create Service Function Chain end")
 173
 174         resp_serializer = CreateSfcRespSerializer(data={"jobId": job_id,
 175                                                         "sfcInstId": data["fpinstid"]})
 176         if not resp_serializer.is_valid():
 177             logger.error(resp_serializer.errors)
 178
 179         return Response(data={"jobId": job_id,
 180                               "sfcInstId": data["fpinstid"]},
 181                         status=status.HTTP_200_OK)