lcm/ns/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 json
  15 import logging
  16 import traceback
  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.ns_create import CreateNSService
  24 from lcm.ns.ns_delete import DeleteNsService
  25 from lcm.ns.ns_get import GetNSInfoService
  26 from lcm.ns.ns_heal import NSHealService
  27 from lcm.ns.ns_instant import InstantNSService
  28 from lcm.ns.ns_manual_scale import NSManualScaleService
  29 from lcm.ns.ns_terminate import TerminateNsService
  30 from lcm.pub.database.models import NSInstModel, ServiceBaseInfoModel
  31 from lcm.pub.utils.jobutil import JobUtil, JOB_TYPE
  32 from lcm.pub.utils.restcall import req_by_msb
  33 from lcm.pub.utils.values import ignore_case_get
  34 from lcm.ns.serializers import CreateNsReqSerializer, CreateNsRespSerializer
  35 from lcm.ns.serializers import QueryNsRespSerializer
  36 from lcm.ns.serializers import NsOperateJobSerializer
  37 from lcm.ns.serializers import InstantNsReqSerializer
  38 from lcm.ns.serializers import TerminateNsReqSerializer
  39 from lcm.ns.serializers import HealNsReqSerializer
  40 from lcm.ns.serializers import InstNsPostDealReqSerializer
  41 from lcm.ns.serializers import ManualScaleNsReqSerializer
  42 from lcm.pub.exceptions import NSLCMException
  43
  44 logger = logging.getLogger(__name__)
  45
  46
  47 class CreateNSView(APIView):
  48     @swagger_auto_schema(
  49         request_body=None,
  50         responses={
  51             status.HTTP_200_OK: QueryNsRespSerializer(help_text="NS instances", many=True),
  52             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
  53         }
  54     )
  55     def get(self, request):
  56         try:
  57             logger.debug("CreateNSView::get")
  58             ret = GetNSInfoService().get_ns_info()
  59             logger.debug("CreateNSView::get::ret=%s", ret)
  60             resp_serializer = QueryNsRespSerializer(data=ret, many=True)
  61             if not resp_serializer.is_valid():
  62                 raise NSLCMException(resp_serializer.errors)
  63             return Response(data=resp_serializer.data, status=status.HTTP_200_OK)
  64         except Exception as e:
  65             logger.error(traceback.format_exc())
  66             logger.error("Exception in GetNS: %s", e.message)
  67             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  68
  69     @swagger_auto_schema(
  70         request_body=CreateNsReqSerializer(),
  71         responses={
  72             status.HTTP_201_CREATED: CreateNsRespSerializer(),
  73             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
  74         }
  75     )
  76     def post(self, request):
  77         logger.debug("Enter CreateNS: %s", request.data)
  78         try:
  79             req_serializer = CreateNsReqSerializer(data=request.data)
  80             if not req_serializer.is_valid():
  81                 raise NSLCMException(req_serializer.errors)
  82
  83             if ignore_case_get(request.data, 'test') == "test":
  84                 return Response(data={'nsInstanceId': "test"}, status=status.HTTP_201_CREATED)
  85             csar_id = ignore_case_get(request.data, 'csarId')
  86             ns_name = ignore_case_get(request.data, 'nsName')
  87             description = ignore_case_get(request.data, 'description')
  88             context = ignore_case_get(request.data, 'context')
  89             ns_inst_id = CreateNSService(csar_id, ns_name, description, context).do_biz()
  90
  91             logger.debug("CreateNSView::post::ret={'nsInstanceId':%s}", ns_inst_id)
  92             resp_serializer = CreateNsRespSerializer(data={'nsInstanceId': ns_inst_id})
  93             if not resp_serializer.is_valid():
  94                 raise NSLCMException(resp_serializer.errors)
  95             return Response(data=resp_serializer.data, status=status.HTTP_201_CREATED)
  96         except Exception as e:
  97             logger.error(traceback.format_exc())
  98             logger.error("Exception in CreateNS: %s", e.message)
  99             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 100
 101
 102 class NSInstView(APIView):
 103     @swagger_auto_schema(
 104         request_body=InstantNsReqSerializer(),
 105         responses={
 106             status.HTTP_200_OK: NsOperateJobSerializer(),
 107             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 108         }
 109     )
 110     def post(self, request, ns_instance_id):
 111         logger.debug("Enter NSInstView::post::ns_instance_id=%s", ns_instance_id)
 112         logger.debug("request.data=%s", request.data)
 113         req_serializer = InstantNsReqSerializer(data=request.data)
 114         if not req_serializer.is_valid():
 115             return Response({'error': req_serializer.errors},
 116                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 117         ack = InstantNSService(ns_instance_id, request.data).do_biz()
 118         resp_serializer = NsOperateJobSerializer(data=ack['data'])
 119         if not resp_serializer.is_valid():
 120             return Response({'error': resp_serializer.errors},
 121                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 122         logger.debug("Leave NSInstView::post::ack=%s", ack)
 123         return Response(data=resp_serializer.data, status=ack['status'])
 124
 125
 126 class TerminateNSView(APIView):
 127     @swagger_auto_schema(
 128         request_body=TerminateNsReqSerializer(),
 129         responses={
 130             status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
 131             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 132         }
 133     )
 134     def post(self, request, ns_instance_id):
 135         try:
 136             logger.debug("Enter TerminateNSView::post %s", request.data)
 137             req_serializer = TerminateNsReqSerializer(data=request.data)
 138             if not req_serializer.is_valid():
 139                 raise NSLCMException(req_serializer.errors)
 140
 141             termination_type = ignore_case_get(request.data, 'terminationType')
 142             graceful_termination_timeout = ignore_case_get(request.data, 'gracefulTerminationTimeout')
 143             job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF, ns_instance_id)
 144             TerminateNsService(ns_instance_id, termination_type, graceful_termination_timeout, job_id).start()
 145
 146             resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
 147             if not resp_serializer.is_valid():
 148                 raise NSLCMException(resp_serializer.errors)
 149             logger.debug("Leave TerminateNSView::post ret=%s", resp_serializer.data)
 150             return Response(data=resp_serializer.data, status=status.HTTP_202_ACCEPTED)
 151         except Exception as e:
 152             logger.error("Exception in CreateNS: %s", e.message)
 153             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 154
 155
 156 class NSHealView(APIView):
 157     @swagger_auto_schema(
 158         request_body=HealNsReqSerializer(),
 159         responses={
 160             status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
 161             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 162         }
 163     )
 164     def post(self, request, ns_instance_id):
 165         try:
 166             logger.debug("Enter HealNSView::post %s", request.data)
 167             logger.debug("Enter HealNSView:: %s", ns_instance_id)
 168             req_serializer = HealNsReqSerializer(data=request.data)
 169             if not req_serializer.is_valid():
 170                 raise NSLCMException(req_serializer.errors)
 171
 172             job_id = JobUtil.create_job("VNF", JOB_TYPE.HEAL_VNF, ns_instance_id)
 173             NSHealService(ns_instance_id, request.data, job_id).start()
 174
 175             resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
 176             if not resp_serializer.is_valid():
 177                 raise NSLCMException(resp_serializer.errors)
 178
 179             logger.debug("Leave HealNSView::post ret=%s", resp_serializer.data)
 180             return Response(data=resp_serializer.data, status=status.HTTP_202_ACCEPTED)
 181         except Exception as e:
 182             logger.error("Exception in HealNSView: %s", e.message)
 183             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 184
 185
 186 class NSDetailView(APIView):
 187     @swagger_auto_schema(
 188         request_body=None,
 189         responses={
 190             status.HTTP_200_OK: QueryNsRespSerializer(help_text="NS instance", many=True),
 191             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error",
 192             status.HTTP_404_NOT_FOUND: "Ns instance does not exist"
 193         }
 194     )
 195     def get(self, request, ns_instance_id):
 196         try:
 197             logger.debug("Enter NSDetailView::get ns(%s)", ns_instance_id)
 198             ns_filter = {"ns_inst_id": ns_instance_id}
 199             ret = GetNSInfoService(ns_filter).get_ns_info()
 200             if not ret:
 201                 return Response(status=status.HTTP_404_NOT_FOUND)
 202             logger.debug("Leave NSDetailView::get::ret=%s", ret)
 203             resp_serializer = QueryNsRespSerializer(data=ret, many=True)
 204             if not resp_serializer.is_valid():
 205                 raise NSLCMException(resp_serializer.errors)
 206             return Response(data=resp_serializer.data, status=status.HTTP_200_OK)
 207         except Exception as e:
 208             logger.error(traceback.format_exc())
 209             logger.error("Exception in GetNSDetail: %s", e.message)
 210             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 211
 212     @swagger_auto_schema(
 213         request_body=None,
 214         responses={
 215             status.HTTP_204_NO_CONTENT: 'successful',
 216             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 217         }
 218     )
 219     def delete(self, request, ns_instance_id):
 220         try:
 221             logger.debug("Enter NSDetailView::delete ns(%s)", ns_instance_id)
 222             DeleteNsService(ns_instance_id).do_biz()
 223             return Response(data={}, status=status.HTTP_204_NO_CONTENT)
 224         except Exception as e:
 225             logger.error(traceback.format_exc())
 226             logger.error("Exception in delete NS: %s", e.message)
 227             return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 228
 229
 230 class NSInstPostDealView(APIView):
 231     @swagger_auto_schema(
 232         request_body=InstNsPostDealReqSerializer(help_text="NS instant post deal"),
 233         responses={
 234             status.HTTP_202_ACCEPTED: "NS instant post deal success",
 235             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 236         }
 237     )
 238     def post(self, request, ns_instance_id):
 239         logger.debug("Enter NSInstPostDealView::post %s, %s", request.data, ns_instance_id)
 240         ns_post_status = ignore_case_get(request.data, 'status')
 241         ns_status = 'ACTIVE' if ns_post_status == 'true' else 'FAILED'
 242         ns_opr_status = 'success' if ns_post_status == 'true' else 'failed'
 243         try:
 244             req_serializer = InstNsPostDealReqSerializer(data=request.data)
 245             if not req_serializer.is_valid():
 246                 raise NSLCMException(req_serializer.errors)
 247             NSInstModel.objects.filter(id=ns_instance_id).update(status=ns_status)
 248             ServiceBaseInfoModel.objects.filter(service_id=ns_instance_id).update(
 249                 active_status=ns_status, status=ns_opr_status)
 250             nsd_info = NSInstModel.objects.filter(id=ns_instance_id)
 251             nsd_id = nsd_info[0].nsd_id
 252             nsd_model = json.loads(nsd_info[0].nsd_model)
 253             if "policies" in nsd_model and nsd_model["policies"]:
 254                 policy = nsd_model["policies"][0]
 255                 if "properties" in policy and policy["properties"]:
 256                     file_url = ignore_case_get(policy["properties"][0], "drl_file_url")
 257                 else:
 258                     file_url = ""
 259                 self.send_policy_request(ns_instance_id, nsd_id, file_url)
 260         except:
 261             logger.error(traceback.format_exc())
 262             return Response(data={'error': 'Failed to update status of NS(%s)' % ns_instance_id},
 263                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 264         logger.debug("*****NS INST %s, %s******", ns_status, ns_opr_status)
 265         return Response(data={'success': 'Update status of NS(%s) to %s' % (ns_instance_id, ns_status)},
 266                         status=status.HTTP_202_ACCEPTED)
 267
 268     def send_policy_request(self, ns_instance_id, nsd_id, file_url):
 269         input_data = {
 270             "nsid": ns_instance_id,
 271             "nsdid": nsd_id,
 272             "fileUri": file_url
 273         }
 274         req_param = json.JSONEncoder().encode(input_data)
 275         policy_engine_url = 'api/polengine/v1/policyinfo'
 276         ret = req_by_msb(policy_engine_url, "POST", req_param)
 277         if ret[0] != 0:
 278             logger.error("Failed to send ns policy req")
 279
 280
 281 class NSManualScaleView(APIView):
 282     @swagger_auto_schema(
 283         request_body=ManualScaleNsReqSerializer(help_text="NS manual scale"),
 284         responses={
 285             status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
 286             status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
 287         }
 288     )
 289     def post(self, request, ns_instance_id):
 290         logger.debug("Enter NSManualScaleView::post %s, %s", request.data, ns_instance_id)
 291         job_id = JobUtil.create_job("NS", JOB_TYPE.MANUAL_SCALE_VNF, ns_instance_id)
 292         try:
 293             req_serializer = ManualScaleNsReqSerializer(data=request.data)
 294             if not req_serializer.is_valid():
 295                 raise NSLCMException(req_serializer.errors)
 296
 297             NSManualScaleService(ns_instance_id, request.data, job_id).start()
 298
 299             resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
 300             if not resp_serializer.is_valid():
 301                 raise NSLCMException(resp_serializer.errors)
 302
 303             return Response(data=resp_serializer.data, status=status.HTTP_202_ACCEPTED)
 304         except Exception as e:
 305             logger.error(traceback.format_exc())
 306             JobUtil.add_job_status(job_id, 255, 'NS scale failed: %s' % e.message)
 307             return Response(data={'error': 'NS scale failed: %s' % ns_instance_id},
 308                             status=status.HTTP_500_INTERNAL_SERVER_ERROR)