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")
59 csarId = ignore_case_get(request.META, 'csarId')
61 filter = {"csarId": csarId}
63 ret = GetNSInfoService(filter).get_ns_info()
64 logger.debug("CreateNSView::get::ret=%s", ret)
65 resp_serializer = QueryNsRespSerializer(data=ret, many=True)
66 if not resp_serializer.is_valid():
67 raise NSLCMException(resp_serializer.errors)
68 return Response(data=resp_serializer.data, status=status.HTTP_200_OK)
69 except Exception as e:
70 logger.error(traceback.format_exc())
71 logger.error("Exception in GetNS: %s", e.message)
72 return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
75 request_body=CreateNsReqSerializer(),
77 status.HTTP_201_CREATED: CreateNsRespSerializer(),
78 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
81 def post(self, request):
82 logger.debug("Enter CreateNS: %s", request.data)
84 req_serializer = CreateNsReqSerializer(data=request.data)
85 if not req_serializer.is_valid():
86 raise NSLCMException(req_serializer.errors)
88 if ignore_case_get(request.data, 'test') == "test":
89 return Response(data={'nsInstanceId': "test"}, status=status.HTTP_201_CREATED)
90 csar_id = ignore_case_get(request.data, 'csarId')
91 ns_name = ignore_case_get(request.data, 'nsName')
92 description = ignore_case_get(request.data, 'description')
93 context = ignore_case_get(request.data, 'context')
94 ns_inst_id = CreateNSService(csar_id, ns_name, description, context).do_biz()
96 logger.debug("CreateNSView::post::ret={'nsInstanceId':%s}", ns_inst_id)
97 resp_serializer = CreateNsRespSerializer(data={'nsInstanceId': ns_inst_id})
98 if not resp_serializer.is_valid():
99 raise NSLCMException(resp_serializer.errors)
100 return Response(data=resp_serializer.data, status=status.HTTP_201_CREATED)
101 except Exception as e:
102 logger.error(traceback.format_exc())
103 logger.error("Exception in CreateNS: %s", e.message)
104 return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
107 class NSInstView(APIView):
108 @swagger_auto_schema(
109 request_body=InstantNsReqSerializer(),
111 status.HTTP_200_OK: NsOperateJobSerializer(),
112 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
115 def post(self, request, ns_instance_id):
116 logger.debug("Enter NSInstView::post::ns_instance_id=%s", ns_instance_id)
117 # req_serializer = InstantNsReqSerializer(data=request.data)
118 # if not req_serializer.is_valid():
119 # return Response({'error': req_serializer.errors},
120 # status=status.HTTP_500_INTERNAL_SERVER_ERROR)
121 ack = InstantNSService(ns_instance_id, request.data).do_biz()
122 resp_serializer = NsOperateJobSerializer(data=ack['data'])
123 if not resp_serializer.is_valid():
124 return Response({'error': resp_serializer.errors},
125 status=status.HTTP_500_INTERNAL_SERVER_ERROR)
126 logger.debug("Leave NSInstView::post::ack=%s", ack)
127 return Response(data=resp_serializer.data, status=ack['status'])
130 class TerminateNSView(APIView):
131 @swagger_auto_schema(
132 request_body=TerminateNsReqSerializer(),
134 status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
135 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
138 def post(self, request, ns_instance_id):
140 logger.debug("Enter TerminateNSView::post %s", request.data)
141 req_serializer = TerminateNsReqSerializer(data=request.data)
142 if not req_serializer.is_valid():
143 raise NSLCMException(req_serializer.errors)
145 termination_type = ignore_case_get(request.data, 'terminationType')
146 graceful_termination_timeout = ignore_case_get(request.data, 'gracefulTerminationTimeout')
147 job_id = JobUtil.create_job("VNF", JOB_TYPE.TERMINATE_VNF, ns_instance_id)
148 TerminateNsService(ns_instance_id, termination_type, graceful_termination_timeout, job_id).start()
150 resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
151 if not resp_serializer.is_valid():
152 raise NSLCMException(resp_serializer.errors)
153 logger.debug("Leave TerminateNSView::post ret=%s", resp_serializer.data)
154 return Response(data=resp_serializer.data, status=status.HTTP_202_ACCEPTED)
155 except Exception as e:
156 logger.error("Exception in CreateNS: %s", e.message)
157 return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
160 class NSHealView(APIView):
161 @swagger_auto_schema(
162 request_body=HealNsReqSerializer(),
164 status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
165 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
168 def post(self, request, ns_instance_id):
170 logger.debug("Enter HealNSView::post %s", request.data)
171 logger.debug("Enter HealNSView:: %s", ns_instance_id)
172 req_serializer = HealNsReqSerializer(data=request.data)
173 if not req_serializer.is_valid():
174 raise NSLCMException(req_serializer.errors)
176 job_id = JobUtil.create_job("VNF", JOB_TYPE.HEAL_VNF, ns_instance_id)
177 NSHealService(ns_instance_id, request.data, job_id).start()
179 resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
180 if not resp_serializer.is_valid():
181 raise NSLCMException(resp_serializer.errors)
183 logger.debug("Leave HealNSView::post ret=%s", resp_serializer.data)
184 return Response(data=resp_serializer.data, status=status.HTTP_202_ACCEPTED)
185 except Exception as e:
186 logger.error("Exception in HealNSView: %s", e.message)
187 return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
190 class NSDetailView(APIView):
191 @swagger_auto_schema(
194 status.HTTP_200_OK: QueryNsRespSerializer(help_text="NS instance", many=True),
195 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error",
196 status.HTTP_404_NOT_FOUND: "Ns instance does not exist"
199 def get(self, request, ns_instance_id):
201 logger.debug("Enter NSDetailView::get ns(%s)", ns_instance_id)
202 ns_filter = {"ns_inst_id": ns_instance_id}
203 ret = GetNSInfoService(ns_filter).get_ns_info()
205 return Response(status=status.HTTP_404_NOT_FOUND)
206 logger.debug("Leave NSDetailView::get::ret=%s", ret)
207 resp_serializer = QueryNsRespSerializer(data=ret, many=True)
208 if not resp_serializer.is_valid():
209 raise NSLCMException(resp_serializer.errors)
210 return Response(data=resp_serializer.data, status=status.HTTP_200_OK)
211 except Exception as e:
212 logger.error(traceback.format_exc())
213 logger.error("Exception in GetNSDetail: %s", e.message)
214 return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
216 @swagger_auto_schema(
219 status.HTTP_204_NO_CONTENT: 'successful',
220 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
223 def delete(self, request, ns_instance_id):
225 logger.debug("Enter NSDetailView::delete ns(%s)", ns_instance_id)
226 DeleteNsService(ns_instance_id).do_biz()
227 return Response(data={}, status=status.HTTP_204_NO_CONTENT)
228 except Exception as e:
229 logger.error(traceback.format_exc())
230 logger.error("Exception in delete NS: %s", e.message)
231 return Response(data={'error': e.message}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
234 class NSInstPostDealView(APIView):
235 @swagger_auto_schema(
236 request_body=InstNsPostDealReqSerializer(help_text="NS instant post deal"),
238 status.HTTP_202_ACCEPTED: "NS instant post deal success",
239 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
242 def post(self, request, ns_instance_id):
243 logger.debug("Enter NSInstPostDealView::post %s, %s", request.data, ns_instance_id)
244 ns_post_status = ignore_case_get(request.data, 'status')
245 ns_status = 'ACTIVE' if ns_post_status == 'true' else 'FAILED'
246 ns_opr_status = 'success' if ns_post_status == 'true' else 'failed'
248 req_serializer = InstNsPostDealReqSerializer(data=request.data)
249 if not req_serializer.is_valid():
250 raise NSLCMException(req_serializer.errors)
251 NSInstModel.objects.filter(id=ns_instance_id).update(status=ns_status)
252 ServiceBaseInfoModel.objects.filter(service_id=ns_instance_id).update(
253 active_status=ns_status, status=ns_opr_status)
254 nsd_info = NSInstModel.objects.filter(id=ns_instance_id)
255 nsd_id = nsd_info[0].nsd_id
256 nsd_model = json.loads(nsd_info[0].nsd_model)
257 if "policies" in nsd_model and nsd_model["policies"]:
258 policy = nsd_model["policies"][0]
259 if "properties" in policy and policy["properties"]:
260 file_url = ignore_case_get(policy["properties"][0], "drl_file_url")
263 self.send_policy_request(ns_instance_id, nsd_id, file_url)
265 logger.error(traceback.format_exc())
266 return Response(data={'error': 'Failed to update status of NS(%s)' % ns_instance_id},
267 status=status.HTTP_500_INTERNAL_SERVER_ERROR)
268 logger.debug("*****NS INST %s, %s******", ns_status, ns_opr_status)
269 return Response(data={'success': 'Update status of NS(%s) to %s' % (ns_instance_id, ns_status)},
270 status=status.HTTP_202_ACCEPTED)
272 def send_policy_request(self, ns_instance_id, nsd_id, file_url):
274 "nsid": ns_instance_id,
278 req_param = json.JSONEncoder().encode(input_data)
279 policy_engine_url = 'api/polengine/v1/policyinfo'
280 ret = req_by_msb(policy_engine_url, "POST", req_param)
282 logger.error("Failed to send ns policy req")
285 class NSManualScaleView(APIView):
286 @swagger_auto_schema(
287 request_body=ManualScaleNsReqSerializer(help_text="NS manual scale"),
289 status.HTTP_202_ACCEPTED: NsOperateJobSerializer(),
290 status.HTTP_500_INTERNAL_SERVER_ERROR: "Inner error"
293 def post(self, request, ns_instance_id):
294 logger.debug("Enter NSManualScaleView::post %s, %s", request.data, ns_instance_id)
295 job_id = JobUtil.create_job("NS", JOB_TYPE.MANUAL_SCALE_VNF, ns_instance_id)
297 req_serializer = ManualScaleNsReqSerializer(data=request.data)
298 if not req_serializer.is_valid():
299 raise NSLCMException(req_serializer.errors)
301 NSManualScaleService(ns_instance_id, request.data, job_id).start()
303 resp_serializer = NsOperateJobSerializer(data={'jobId': job_id})
304 if not resp_serializer.is_valid():
305 raise NSLCMException(resp_serializer.errors)
307 return Response(data=resp_serializer.data, status=status.HTTP_202_ACCEPTED)
308 except Exception as e:
309 logger.error(traceback.format_exc())
310 JobUtil.add_job_status(job_id, 255, 'NS scale failed: %s' % e.message)
311 return Response(data={'error': 'NS scale failed: %s' % ns_instance_id},
312 status=status.HTTP_500_INTERNAL_SERVER_ERROR)