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.
21 from drf_yasg import openapi
22 from drf_yasg.utils import swagger_auto_schema
23 from rest_framework import status
24 from rest_framework.response import Response
25 from rest_framework.views import APIView
26 from django.http import StreamingHttpResponse
28 from driver.interfaces.serializers import HealReqSerializer, InstScaleHealRespSerializer, ScaleReqSerializer, \
29 NotifyReqSerializer, GrantRespSerializer, GrantReqSerializer, JobQueryRespSerializer, TerminateVnfRequestSerializer, \
30 InstantiateVnfRequestSerializer, QueryVnfResponseSerializer
31 from driver.pub.config.config import VNF_FTP
32 from driver.pub.utils import restcall
33 from driver.pub.utils.restcall import req_by_msb
37 logger = logging.getLogger(__name__)
40 def load_json_file(file_name):
41 json_file = os.path.join(os.path.dirname(__file__), "data/" + file_name)
43 json_data = json.JSONDecoder().decode(f.read())
48 def read(file_path, start, end):
49 fp = open(file_path, 'rb')
52 while pos + CHUNK_SIZE < end:
53 yield fp.read(CHUNK_SIZE)
55 yield fp.read(end - pos)
58 def parse_file_range(file_path, file_range):
59 start, end = 0, os.path.getsize(file_path)
61 [start, end] = file_range.split('-')
62 start, end = start.strip(), end.strip()
63 start, end = int(start), int(end)
68 return "=================%s==================" % inspect.stack()[1][3]
71 def ignorcase_get(args, key):
79 if old_key.upper() == key.upper():
84 # Query vnfm_info from nslcm
85 def get_vnfminfo_from_nslcm(vnfmid):
86 ret = req_by_msb("api/nslcm/v1/vnfms/%s" % vnfmid, "GET")
90 # Query vnfd_info from nslcm
91 def vnfd_get(vnfpackageid):
92 ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % vnfpackageid, "GET")
96 # Query vnfpackage_info from nslcm
97 def vnfpackage_get(csarid):
98 ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % csarid, "GET")
102 class InstantiateVnf(APIView):
103 @swagger_auto_schema(
104 request_body=InstantiateVnfRequestSerializer(),
106 status.HTTP_200_OK: InstScaleHealRespSerializer(),
107 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
110 def post(self, request, vnfmid):
112 logger.debug("[%s] request.data=%s", fun_name(), request.data)
113 instantiateVnfRequestSerializer = InstantiateVnfRequestSerializer(data=request.data)
114 if not instantiateVnfRequestSerializer.is_valid():
115 raise Exception(instantiateVnfRequestSerializer.errors)
117 ret = get_vnfminfo_from_nslcm(vnfmid)
119 raise Exception(ret[1])
121 vnfm_info = json.JSONDecoder().decode(ret[1])
122 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
123 vnf_package_id = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfPackageId")
124 ret = vnfd_get(vnf_package_id)
126 raise Exception(ret[1])
128 vnfd_info = json.JSONDecoder().decode(ret[1])
129 logger.debug("[%s] vnfd_info=%s", fun_name(), vnfd_info)
130 csar_id = ignorcase_get(vnfd_info, "csarId")
131 ret = vnfpackage_get(csar_id)
133 raise Exception(ret[1])
135 vnf_package_info = json.JSONDecoder().decode(ret[1])
136 packageInfo = ignorcase_get(vnf_package_info, "packageInfo")
137 logger.debug("[%s] packageInfo=%s", fun_name(), packageInfo)
138 logger.debug("VNF_FTP=%s", VNF_FTP)
142 "vnfd_id": packageInfo.get("vnfdId"),
143 "deployflavorid": "TODO",
148 additionalParam = ignorcase_get(instantiateVnfRequestSerializer.data, "additionalParam")
149 for name, value in ignorcase_get(additionalParam, "inputs").items():
150 data["inputs"].append({"key_name": name, "value": value, "type": "TODO"})
152 logger.debug("[%s] call_req data=%s", fun_name(), data)
154 ret = restcall.call_req(
155 base_url=ignorcase_get(vnfm_info, "url"),
156 user=ignorcase_get(vnfm_info, "userName"),
157 passwd=ignorcase_get(vnfm_info, "password"),
158 auth_type=restcall.rest_no_auth,
161 content=json.JSONEncoder().encode(data))
163 logger.debug("[%s] call_req ret=%s", fun_name(), ret)
165 raise Exception(ret[1])
167 resp = json.JSONDecoder().decode(ret[1])
169 "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
170 "jobId": ignorcase_get(resp, "JobId")
172 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
173 instRespSerializer = InstScaleHealRespSerializer(data=resp_data)
174 if not instRespSerializer.is_valid():
175 raise Exception(instRespSerializer.errors)
177 logger.debug("[%s] instRespSerializer.data=%s", fun_name(), instRespSerializer.data)
178 return Response(data=instRespSerializer.data, status=status.HTTP_200_OK)
179 except Exception as e:
180 logger.error("Error occurred when instantiating VNF,error:%s", e.message)
181 logger.error(traceback.format_exc())
182 return Response(data={'error': 'InstantiateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
185 class TerminateVnf(APIView):
186 @swagger_auto_schema(
187 request_body=TerminateVnfRequestSerializer(),
189 status.HTTP_200_OK: InstScaleHealRespSerializer(),
190 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
193 def post(self, request, vnfmid, vnfInstanceId):
195 logger.debug("[%s] request.data=%s", fun_name(), request.data)
196 terminate_vnf_request_serializer = TerminateVnfRequestSerializer(data=request.data)
197 if not terminate_vnf_request_serializer.is_valid():
198 raise Exception(terminate_vnf_request_serializer.errors)
200 ret = get_vnfminfo_from_nslcm(vnfmid)
202 raise Exception(ret[1])
204 vnfm_info = json.JSONDecoder().decode(ret[1])
205 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
206 ret = restcall.call_req(
207 base_url=ignorcase_get(vnfm_info, "url"),
208 user=ignorcase_get(vnfm_info, "userName"),
209 passwd=ignorcase_get(vnfm_info, "password"),
210 auth_type=restcall.rest_no_auth,
211 resource="v1/vnfs/%s" % vnfInstanceId,
213 content=json.JSONEncoder().encode(terminate_vnf_request_serializer.data))
215 raise Exception(ret[1])
217 resp = json.JSONDecoder().decode(ret[1])
219 "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
220 "jobId": ignorcase_get(resp, "JobId")
222 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
223 terminateRespSerializer = InstScaleHealRespSerializer(data=resp_data)
224 if not terminateRespSerializer.is_valid():
225 raise Exception(terminateRespSerializer.errors)
226 return Response(data=terminateRespSerializer.data, status=status.HTTP_200_OK)
227 except Exception as e:
228 logger.error("Error occurred when terminating VNF,error: %s", e.message)
229 logger.error(traceback.format_exc())
230 return Response(data={'error': 'TerminateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
233 class QueryVnf(APIView):
234 @swagger_auto_schema(
236 status.HTTP_200_OK: QueryVnfResponseSerializer(),
237 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
240 def get(self, request, vnfmid, vnfInstanceId):
242 logger.debug("[%s] request.data=%s", fun_name(), request.data)
243 ret = get_vnfminfo_from_nslcm(vnfmid)
245 raise Exception(ret[1])
247 vnfm_info = json.JSONDecoder().decode(ret[1])
248 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
249 ret = restcall.call_req(
250 base_url=ignorcase_get(vnfm_info, "url"),
251 user=ignorcase_get(vnfm_info, "userName"),
252 passwd=ignorcase_get(vnfm_info, "password"),
253 auth_type=restcall.rest_no_auth,
254 resource="v1/vnfs/%s" % vnfInstanceId,
256 content=json.JSONEncoder().encode({}))
258 raise Exception(ret[1])
260 resp = json.JSONDecoder().decode(ret[1])
261 vnf_status = ignorcase_get(resp, "vnfinstancestatus")
262 resp_data = {"vnfInfo": {"vnfStatus": vnf_status}}
263 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
264 queryVnfResponseSerializer = QueryVnfResponseSerializer(data=resp_data)
265 if not queryVnfResponseSerializer.is_valid():
266 raise Exception(queryVnfResponseSerializer.errors)
267 return Response(data=queryVnfResponseSerializer.data, status=status.HTTP_200_OK)
268 except Exception as e:
269 logger.error("Error occurred when querying VNF information,error:%s", e.message)
270 logger.error(traceback.format_exc())
271 return Response(data={'error': 'QueryVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
274 class JobView(APIView):
275 @swagger_auto_schema(
277 openapi.Parameter('responseId',
280 type=openapi.TYPE_INTEGER
284 status.HTTP_200_OK: JobQueryRespSerializer(),
285 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
288 def get(self, request, vnfmid, jobid):
290 logger.debug("[%s] request.data=%s", fun_name(), request.data)
291 ret = get_vnfminfo_from_nslcm(vnfmid)
293 raise Exception(ret[1])
295 vnfm_info = json.JSONDecoder().decode(ret[1])
296 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
297 operation_status_url = '/v1/jobs/{jobId}?NFVOID={nfvoId}&VNFMID={vnfmId}&ResponseID={responseId}'
298 responseId = ignorcase_get(request.GET, 'responseId')
299 query_url = operation_status_url.format(jobId=jobid, nfvoId=1, vnfmId=vnfmid, responseId=responseId)
300 ret = restcall.call_req(
301 base_url=ignorcase_get(vnfm_info, 'url'),
302 user=ignorcase_get(vnfm_info, 'userName'),
303 passwd=ignorcase_get(vnfm_info, 'password'),
304 auth_type=restcall.rest_no_auth,
310 raise Exception(ret[1])
312 resp_data = json.JSONDecoder().decode(ret[1])
313 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
314 jobQueryRespSerializer = JobQueryRespSerializer(data=resp_data)
315 if not jobQueryRespSerializer.is_valid():
316 raise Exception(jobQueryRespSerializer.errors)
318 return Response(data=jobQueryRespSerializer.data, status=status.HTTP_200_OK)
319 except Exception as e:
320 logger.error("Error occurred when getting operation status information,error:%s", e.message)
321 logger.error(traceback.format_exc())
322 return Response(data={'error': 'QueryJob expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
325 class GrantVnf(APIView):
326 @swagger_auto_schema(
327 request_body=GrantReqSerializer(),
329 status.HTTP_201_CREATED: GrantRespSerializer(),
330 status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
333 def put(self, request):
334 logger.debug("=====GrantVnf=====")
336 logger.debug("request.data = %s", request.data)
337 grantReqSerializer = GrantReqSerializer(data=request.data)
338 if not grantReqSerializer.is_valid():
339 raise Exception(grantReqSerializer.errors)
341 logger.debug("grantReqSerializer.data = %s", grantReqSerializer.data)
343 "vnfInstanceId": ignorcase_get(grantReqSerializer.data, "vnfistanceid"),
344 "vnfDescriptorId": "",
347 "vnfmid": ignorcase_get(grantReqSerializer.data, "vnfmid"),
348 "vimid": ignorcase_get(grantReqSerializer.data, "vimid"),
349 "tenant": ignorcase_get(grantReqSerializer.data, "tenant")
352 if ignorcase_get(grantReqSerializer.data, "operationright") == 0:
353 req_data["lifecycleOperation"] = "Instantiate"
354 for vm in ignorcase_get(grantReqSerializer.data, "vmlist"):
355 for i in range(int(ignorcase_get(vm, "VMNumber"))):
356 req_data["addresource"].append(
359 "resourceDefinitionId": i,
360 "vdu": ignorcase_get(vm, "VMFlavor"),
361 "vimid": ignorcase_get(vm, "vimid"),
362 "tenant": ignorcase_get(vm, "tenant")})
364 logger.debug("req_data=%s", req_data)
365 ret = req_by_msb('api/nslcm/v1/ns/grantvnf', "POST", content=json.JSONEncoder().encode(req_data))
366 logger.info("ret = %s", ret)
368 raise Exception(ret[1])
370 resp = json.JSONDecoder().decode(ret[1])
372 'vimid': ignorcase_get(resp['vim'], 'vimid'),
373 'tenant': ignorcase_get(ignorcase_get(resp['vim'], 'accessinfo'), 'tenant')
375 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
376 grantRespSerializer = GrantRespSerializer(data=resp_data)
377 if not grantRespSerializer.is_valid():
378 raise Exception(grantRespSerializer.errors)
380 logger.debug("grantRespSerializer.data=%s", grantRespSerializer.data)
381 return Response(data=grantRespSerializer.data, status=status.HTTP_201_CREATED)
382 except Exception as e:
383 logger.error("Error occurred in Grant VNF, error: %s", e.message)
384 logger.error(traceback.format_exc())
385 return Response(data={'error': 'Grant expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
388 class Notify(APIView):
389 @swagger_auto_schema(
390 request_body=NotifyReqSerializer(),
392 status.HTTP_200_OK: 'Successfully',
393 status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
396 def post(self, request):
398 logger.debug("[%s]request.data = %s", fun_name(), request.data)
399 notifyReqSerializer = NotifyReqSerializer(data=request.data)
400 if not notifyReqSerializer.is_valid():
401 raise Exception(notifyReqSerializer.errors)
403 logger.debug("[%s]notifyReqSerializer.data = %s", fun_name(), notifyReqSerializer.data)
406 "vnfInstanceId": ignorcase_get(notifyReqSerializer.data, "vnfinstanceid"),
407 "vnfmId": ignorcase_get(notifyReqSerializer.data, "vnfmid"),
408 "vimId": ignorcase_get(notifyReqSerializer.data, "vimid"),
409 "operation": ignorcase_get(notifyReqSerializer.data, "EventType"),
413 "affectedVirtualStorage": [],
417 extension = ignorcase_get(notifyReqSerializer.data, "extension")
418 openo_notification = ignorcase_get(extension, "openo_notification")
419 if openo_notification:
420 affectedvnfcs = ignorcase_get(openo_notification, "affectedVnfc")
421 affectedvls = ignorcase_get(openo_notification, "affectedvirtuallink")
422 affectedcps = ignorcase_get(openo_notification, "affectedCp")
423 vnfdmodule = ignorcase_get(openo_notification, "vnfdmodule")
425 affectedvnfcs = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvnfc")
426 affectedvls = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvl")
427 affectedcps = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedcp")
428 vnfdmodule = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "vnfdmodule")
430 req_data["vnfdmodule"] = vnfdmodule
432 for affectedvnfc in affectedvnfcs:
433 req_data["affectedVnfc"].append({
434 "vnfcInstanceId": ignorcase_get(affectedvnfc, "vnfcInstanceId"),
435 "vduId": ignorcase_get(affectedvnfc, "vduId"),
436 "changeType": ignorcase_get(affectedvnfc, "changeType"),
437 "vimId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "vimId"),
438 "vmId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceId"),
439 "vmName": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceName")
442 for affectedvl in affectedvls:
443 req_data["affectedVl"].append({
444 "vlInstanceId": ignorcase_get(affectedvl, "virtualLinkInstanceId"),
445 "changeType": ignorcase_get(affectedvl, "changeType"),
446 "vimId": ignorcase_get(ignorcase_get(affectedvl, "networkResource"), "vimId"),
447 "vldId": ignorcase_get(affectedvl, "virtuallinkdescid"),
449 "resourceType": "network",
450 "resourceId": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourceid"),
451 "resourceName": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourcename")
455 for affectedcp in affectedcps:
456 req_data["affectedCp"].append(affectedcp)
458 vnfmid = ignorcase_get(req_data, 'vnfmId')
459 vnfInstanceId = ignorcase_get(req_data, 'vnfinstanceid')
460 notify_url = 'api/nslcm/v1/ns/%s/vnfs/%s/Notify' % (vnfmid, vnfInstanceId)
461 logger.debug("notify_url = %s", notify_url)
462 logger.debug("req_data = %s", req_data)
463 ret = req_by_msb(notify_url, "POST", content=json.JSONEncoder().encode(req_data))
465 logger.debug("[%s]data = %s", fun_name(), ret)
467 raise Exception(ret[1])
469 return Response(data=None, status=status.HTTP_200_OK)
470 except Exception as e:
471 logger.error("Error occurred in LCM notification,error: %s", e.message)
472 logger.error(traceback.format_exc())
473 return Response(data={'error': 'Notify expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
476 class Scale(APIView):
477 @swagger_auto_schema(
478 request_body=ScaleReqSerializer(),
480 status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
481 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
484 def post(self, request, vnfmid, vnfInstanceId):
485 logger.debug("====scale_vnf===")
487 logger.debug("request.data = %s", request.data)
488 logger.debug("requested_url = %s", request.get_full_path())
489 scaleReqSerializer = ScaleReqSerializer(data=request.data)
490 if not scaleReqSerializer.is_valid():
491 raise Exception(scaleReqSerializer.errors)
493 ret = get_vnfminfo_from_nslcm(vnfmid)
495 raise Exception(ret[1])
497 vnfm_info = json.JSONDecoder().decode(ret[1])
498 scale_type = ignorcase_get(scaleReqSerializer.data, "type")
499 aspect_id = ignorcase_get(scaleReqSerializer.data, "aspectId")
500 number_of_steps = ignorcase_get(scaleReqSerializer.data, "numberOfSteps")
504 'scaletype': '0' if scale_type == 'SCALE_OUT' else '1',
506 'VMNumber': number_of_steps,
507 'VMFlavor': aspect_id
512 logger.debug("data = %s", data)
513 ret = restcall.call_req(
514 base_url=ignorcase_get(vnfm_info, "url"),
515 user=ignorcase_get(vnfm_info, "userName"),
516 passwd=ignorcase_get(vnfm_info, "password"),
517 auth_type=restcall.rest_no_auth,
518 resource='/v1/vnfs/{vnfInstanceID}/scale'.format(vnfInstanceID=vnfInstanceId),
520 content=json.JSONEncoder().encode(data))
521 logger.debug("ret=%s", ret)
523 raise Exception('scale error')
525 scaleRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
526 if not scaleRespSerializer.is_valid():
527 raise Exception(scaleRespSerializer.errors)
529 logger.debug("scaleRespSerializer.data=%s", scaleRespSerializer.data)
530 return Response(data=scaleRespSerializer.data, status=status.HTTP_202_ACCEPTED)
531 except Exception as e:
532 logger.error("Error occurred when scaling VNF,error:%s", e.message)
533 logger.error(traceback.format_exc())
534 return Response(data={'error': 'Scale expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
538 @swagger_auto_schema(
539 request_body=HealReqSerializer(),
541 status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
542 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
545 def post(self, request, vnfmid, vnfInstanceId):
546 logger.debug("====heal_vnf===")
548 logger.debug("request.data = %s", request.data)
549 logger.debug("requested_url = %s", request.get_full_path())
550 healReqSerializer = HealReqSerializer(data=request.data)
551 if not healReqSerializer.is_valid():
552 raise Exception(healReqSerializer.errors)
554 logger.debug("healReqSerializer.data = %s", healReqSerializer.data)
555 logger.debug("vnfmid = %s", vnfmid)
556 ret = get_vnfminfo_from_nslcm(vnfmid)
558 raise Exception(ret[1])
560 vnfm_info = json.JSONDecoder().decode(ret[1])
562 "action": ignorcase_get(healReqSerializer.data, 'action'),
563 "lifecycleoperation": "operate",
567 affectedvm = ignorcase_get(healReqSerializer.data, 'affectedvm')
568 if isinstance(affectedvm, list):
569 req_data['affectedvm'] = affectedvm
571 req_data['affectedvm'].append(affectedvm)
573 logger.debug("req_data = %s", req_data)
574 ret = restcall.call_req(
575 base_url=ignorcase_get(vnfm_info, "url"),
576 user=ignorcase_get(vnfm_info, "userName"),
577 passwd=ignorcase_get(vnfm_info, "password"),
578 auth_type=restcall.rest_no_auth,
579 resource='/api/v1/nf_m_i/nfs/{vnfInstanceID}/vms/operation'.format(vnfInstanceID=vnfInstanceId),
581 content=json.JSONEncoder().encode(req_data))
582 logger.debug("ret=%s", ret)
584 raise Exception('heal error')
586 healRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
587 if not healRespSerializer.is_valid():
588 raise Exception(healRespSerializer.errors)
590 logger.debug("healRespSerializer.data=%s", healRespSerializer.data)
591 return Response(data=healRespSerializer.data, status=status.HTTP_202_ACCEPTED)
592 except Exception as e:
593 logger.error("Error occurred when healing VNF,error:%s", e.message)
594 logger.error(traceback.format_exc())
595 return Response(data={'error': 'Heal expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
598 def get_vdus(nf_model, aspect_id):
599 associated_group = ''
601 vnf_flavours = nf_model['vnf_flavours']
602 for vnf_flaour in vnf_flavours:
603 scaling_aspects = vnf_flaour['scaling_aspects']
604 for aspect in scaling_aspects:
605 if aspect_id == aspect['id']:
606 associated_group = aspect['associated_group']
608 if not associated_group:
609 logger.error('Cannot find the corresponding element group')
610 raise Exception('Cannot find the corresponding element group')
611 for element_group in nf_model['element_groups']:
612 if element_group['group_id'] == associated_group:
613 members = element_group['members']
615 logger.error('Cannot find the corresponding members')
616 raise Exception('Cannot find the corresponding members')
620 class SampleList(APIView):
621 @swagger_auto_schema(
623 status.HTTP_200_OK: 'Successfully'})
624 def get(self, request):
626 return Response({"status": "active"})
629 class Subscribe(APIView):
630 def get(self, request):
631 logger.debug("====Subscribe get====")
634 "subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657",
639 "notificationuri": " https://127.0.0.1:80/v2/vnfm/vnfds/notification",
642 return Response(data=resp_data, status=status.HTTP_200_OK)
644 def post(self, request):
645 logger.debug("====Subscribe post====")
646 resp_data = {"subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657"}
647 return Response(data=resp_data, status=status.HTTP_201_CREATED)
650 class SubscribeDetail(APIView):
651 def delete(self, request, subscribeId):
652 logger.debug("====SubscribeDetail delete %s====", subscribeId)
653 return Response(status=status.HTTP_204_NO_CONTENT)
656 class VnfPkgs(APIView):
657 def get(self, request):
658 logger.debug("====VnfPkgs get====")
661 "packageid": "924fc980-4530-11e9-ae68-acc860114657",
664 "vnfdfile": "MRP6600_FS_SRIOV_4NIC_200W.zip",
665 "imagefiles": ["MRP6600_FS_SRIOV_MRPISU_IMGV500R008C20SPC030T.tar"],
666 "swfiles": ["MRP6600_SRV_V500R008C20SPC030T.tar"],
667 "description": "This is a service for vCPE.",
670 return Response(data=resp_data, status=status.HTTP_200_OK)
673 class VnfPkg(APIView):
674 def get(self, request, packageId, fileName):
675 logger.debug("====VnfPkg get====%s, %s", packageId, fileName)
676 file_range = request.META.get('RANGE')
677 logger.debug('file_range: %s' % file_range)
679 local_file_path = fileName
680 start, end = parse_file_range(local_file_path, file_range)
681 file_iterator = read(local_file_path, start, end)
682 return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)