1 # Copyright 2016-2017 ZTE Corporation.
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
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
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
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
44 logger = logging.getLogger(__name__)
47 class CreateNSView(APIView):
51 status.HTTP_200_OK: QueryNsRespSerializer(help_text="NS instances", many=True),
52 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
55 def get(self, request):
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)
70 request_body=CreateNsReqSerializer(),
72 status.HTTP_201_CREATED: CreateNsRespSerializer(),
73 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
76 def post(self, request):
77 logger.debug("Enter CreateNS: %s", request.data)
79 req_serializer = CreateNsReqSerializer(data=request.data)
80 if not req_serializer.is_valid():
81 raise NSLCMException(req_serializer.errors)
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()
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)
102 class NSInstView(APIView):
103 @swagger_auto_schema(
104 request_body=InstantNsReqSerializer(),
106 status.HTTP_200_OK: NsOperateJobSerializer(),
107 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
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'])
126 class TerminateNSView(APIView):
127 @swagger_auto_schema(
128 request_body=TerminateNsReqSerializer(),
130 status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
131 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
134 def post(self, request, ns_instance_id):
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)
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()
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)
156 class NSHealView(APIView):
157 @swagger_auto_schema(
158 request_body=HealNsReqSerializer(),
160 status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
161 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
164 def post(self, request, ns_instance_id):
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)
172 job_id = JobUtil.create_job("VNF", JOB_TYPE.HEAL_VNF, ns_instance_id)
173 NSHealService(ns_instance_id, request.data, job_id).start()
175 resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
176 if not resp_serializer.is_valid():
177 raise NSLCMException(resp_serializer.errors)
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)
186 class NSDetailView(APIView):
187 @swagger_auto_schema(
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"
195 def get(self, request, ns_instance_id):
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()
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)
212 @swagger_auto_schema(
215 status.HTTP_204_NO_CONTENT: 'successful',
216 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
219 def delete(self, request, ns_instance_id):
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)
230 class NSInstPostDealView(APIView):
231 @swagger_auto_schema(
232 request_body=InstNsPostDealReqSerializer(help_text="NS instant post deal"),
234 status.HTTP_202_ACCEPTED: "NS instant post deal success",
235 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
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'
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")
259 self.send_policy_request(ns_instance_id, nsd_id, file_url)
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)
268 def send_policy_request(self, ns_instance_id, nsd_id, file_url):
270 "nsid": ns_instance_id,
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)
278 logger.error("Failed to send ns policy req")
281 class NSManualScaleView(APIView):
282 @swagger_auto_schema(
283 request_body=ManualScaleNsReqSerializer(help_text="NS manual scale"),
285 status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
286 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
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)
293 req_serializer = ManualScaleNsReqSerializer(data=request.data)
294 if not req_serializer.is_valid():
295 raise NSLCMException(req_serializer.errors)
297 NSManualScaleService(ns_instance_id, request.data, job_id).start()
299 resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
300 if not resp_serializer.is_valid():
301 raise NSLCMException(resp_serializer.errors)
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)