lcm/ns/sfcs/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 traceback
  19 import uuid
  20
  21 import time
  22 from rest_framework import status
  23 from rest_framework.response import Response
  24 from rest_framework.views import APIView
  25 from drf_yasg.utils import swagger_auto_schema
  26
  27 from lcm.ns.sfcs.create_flowcla import CreateFlowClassifier
  28 from lcm.ns.sfcs.create_port_chain import CreatePortChain
  29 from lcm.ns.sfcs.create_portpairgp import CreatePortPairGroup
  30 from lcm.ns.sfcs.create_sfc_worker import CreateSfcWorker
  31 from lcm.ns.sfcs.sfc_instance import SfcInstance
  32 from lcm.ns.sfcs.utils import get_fp_id, ignorcase_get
  33 from lcm.ns.sfcs.serializers import CreateSfcInstReqSerializer, CreateSfcInstRespSerializer
  34 from lcm.ns.sfcs.serializers import CreateSfcReqSerializer, CreateSfcRespSerializer
  35 from lcm.ns.sfcs.serializers import CreatePortPairGpSerializer
  36 from lcm.ns.sfcs.serializers import CreateFlowClaSerializer
  37 from lcm.ns.sfcs.serializers import CreatePortChainSerializer
  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)