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
27 from driver.interfaces.serializers import HealReqSerializer, InstScaleHealRespSerializer, ScaleReqSerializer, \
28 NotifyReqSerializer, GrantRespSerializer, GrantReqSerializer, JobQueryRespSerializer, TerminateVnfRequestSerializer, \
29 InstantiateVnfRequestSerializer, QueryVnfResponseSerializer
30 from driver.pub.config.config import VNF_FTP
31 from driver.pub.utils import restcall
32 from driver.pub.utils.restcall import req_by_msb
34 logger = logging.getLogger(__name__)
37 def load_json_file(file_name):
38 json_file = os.path.join(os.path.dirname(__file__), "data/" + file_name)
40 json_data = json.JSONDecoder().decode(f.read())
46 return "=================%s==================" % inspect.stack()[1][3]
49 def ignorcase_get(args, key):
57 if old_key.upper() == key.upper():
62 # Query vnfm_info from nslcm
63 def get_vnfminfo_from_nslcm(vnfmid):
64 ret = req_by_msb("api/nslcm/v1/vnfms/%s" % vnfmid, "GET")
68 # Query vnfd_info from nslcm
69 def vnfd_get(vnfpackageid):
70 ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % vnfpackageid, "GET")
74 # Query vnfpackage_info from nslcm
75 def vnfpackage_get(csarid):
76 ret = req_by_msb("api/nslcm/v1/vnfpackage/%s" % csarid, "GET")
80 class InstantiateVnf(APIView):
82 request_body=InstantiateVnfRequestSerializer(),
84 status.HTTP_200_OK: InstScaleHealRespSerializer(),
85 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
88 def post(self, request, vnfmid):
90 logger.debug("[%s] request.data=%s", fun_name(), request.data)
91 instantiateVnfRequestSerializer = InstantiateVnfRequestSerializer(data=request.data)
92 if not instantiateVnfRequestSerializer.is_valid():
93 raise Exception(instantiateVnfRequestSerializer.errors)
95 ret = get_vnfminfo_from_nslcm(vnfmid)
97 raise Exception(ret[1])
99 vnfm_info = json.JSONDecoder().decode(ret[1])
100 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
101 vnf_package_id = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfPackageId")
102 ret = vnfd_get(vnf_package_id)
104 raise Exception(ret[1])
106 vnfd_info = json.JSONDecoder().decode(ret[1])
107 logger.debug("[%s] vnfd_info=%s", fun_name(), vnfd_info)
108 csar_id = ignorcase_get(vnfd_info, "csarId")
109 ret = vnfpackage_get(csar_id)
111 raise Exception(ret[1])
113 vnf_package_info = json.JSONDecoder().decode(ret[1])
114 packageInfo = ignorcase_get(vnf_package_info, "packageInfo")
115 logger.debug("[%s] packageInfo=%s", fun_name(), packageInfo)
121 vnfdModel = json.loads(ignorcase_get(packageInfo, "vnfdModel"))
122 metadata = ignorcase_get(vnfdModel, "metadata")
123 vnfd_name = ignorcase_get(metadata, "name")
124 # TODO convert sdc vnf package to vnf vender package
126 if "SPGW" in vnfd_name.upper():
127 data["VNFD"] = VNF_FTP + "SPGW"
128 inputs = load_json_file("SPGW" + "_inputs.json")
129 elif "MME" in vnfd_name.upper():
130 data["VNFD"] = VNF_FTP + "MME"
131 inputs = load_json_file("MME" + "_inputs.json")
133 data["VNFD"] = ignorcase_get(packageInfo, "downloadUri")
135 data["VNFURL"] = data["VNFD"]
137 additionalParam = ignorcase_get(instantiateVnfRequestSerializer.data, "additionalParam")
138 for name, value in ignorcase_get(additionalParam, "inputs").items():
139 inputs.append({"name": name, "value": value})
141 data["extension"]["inputs"] = json.dumps(inputs)
142 data["extension"]["extVirtualLinks"] = ignorcase_get(additionalParam, "extVirtualLinks")
143 data["extension"]["vnfinstancename"] = ignorcase_get(instantiateVnfRequestSerializer.data, "vnfInstanceName")
144 data["extension"]["vnfid"] = data["VNFD"]
145 data["extension"]["multivim"] = 0
146 logger.debug("[%s] call_req data=%s", fun_name(), data)
148 ret = restcall.call_req(
149 base_url=ignorcase_get(vnfm_info, "url"),
150 user=ignorcase_get(vnfm_info, "userName"),
151 passwd=ignorcase_get(vnfm_info, "password"),
152 auth_type=restcall.rest_no_auth,
155 content=json.JSONEncoder().encode(data))
157 logger.debug("[%s] call_req ret=%s", fun_name(), ret)
159 raise Exception(ret[1])
161 resp = json.JSONDecoder().decode(ret[1])
163 "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
164 "jobId": ignorcase_get(resp, "JobId")
166 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
167 instRespSerializer = InstScaleHealRespSerializer(data=resp_data)
168 if not instRespSerializer.is_valid():
169 raise Exception(instRespSerializer.errors)
171 logger.debug("[%s] instRespSerializer.data=%s", fun_name(), instRespSerializer.data)
172 return Response(data=instRespSerializer.data, status=status.HTTP_200_OK)
173 except Exception as e:
174 logger.error("Error occurred when instantiating VNF,error:%s", e.message)
175 logger.error(traceback.format_exc())
176 return Response(data={'error': 'InstantiateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
179 class TerminateVnf(APIView):
180 @swagger_auto_schema(
181 request_body=TerminateVnfRequestSerializer(),
183 status.HTTP_200_OK: InstScaleHealRespSerializer(),
184 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
187 def post(self, request, vnfmid, vnfInstanceId):
189 logger.debug("[%s] request.data=%s", fun_name(), request.data)
190 terminate_vnf_request_serializer = TerminateVnfRequestSerializer(data=request.data)
191 if not terminate_vnf_request_serializer.is_valid():
192 raise Exception(terminate_vnf_request_serializer.errors)
194 ret = get_vnfminfo_from_nslcm(vnfmid)
196 raise Exception(ret[1])
198 vnfm_info = json.JSONDecoder().decode(ret[1])
199 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
200 ret = restcall.call_req(
201 base_url=ignorcase_get(vnfm_info, "url"),
202 user=ignorcase_get(vnfm_info, "userName"),
203 passwd=ignorcase_get(vnfm_info, "password"),
204 auth_type=restcall.rest_no_auth,
205 resource="v1/vnfs/%s" % vnfInstanceId,
207 content=json.JSONEncoder().encode(terminate_vnf_request_serializer.data))
209 raise Exception(ret[1])
211 resp = json.JSONDecoder().decode(ret[1])
213 "vnfInstanceId": ignorcase_get(resp, "VNFInstanceID"),
214 "jobId": ignorcase_get(resp, "JobId")
216 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
217 terminateRespSerializer = InstScaleHealRespSerializer(data=resp_data)
218 if not terminateRespSerializer.is_valid():
219 raise Exception(terminateRespSerializer.errors)
220 return Response(data=terminateRespSerializer.data, status=status.HTTP_200_OK)
221 except Exception as e:
222 logger.error("Error occurred when terminating VNF,error: %s", e.message)
223 logger.error(traceback.format_exc())
224 return Response(data={'error': 'TerminateVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
227 class QueryVnf(APIView):
228 @swagger_auto_schema(
230 status.HTTP_200_OK: QueryVnfResponseSerializer(),
231 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
234 def get(self, request, vnfmid, vnfInstanceId):
236 logger.debug("[%s] request.data=%s", fun_name(), request.data)
237 ret = get_vnfminfo_from_nslcm(vnfmid)
239 raise Exception(ret[1])
241 vnfm_info = json.JSONDecoder().decode(ret[1])
242 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
243 ret = restcall.call_req(
244 base_url=ignorcase_get(vnfm_info, "url"),
245 user=ignorcase_get(vnfm_info, "userName"),
246 passwd=ignorcase_get(vnfm_info, "password"),
247 auth_type=restcall.rest_no_auth,
248 resource="v1/vnfs/%s" % vnfInstanceId,
250 content=json.JSONEncoder().encode({}))
252 raise Exception(ret[1])
254 resp = json.JSONDecoder().decode(ret[1])
255 vnf_status = ignorcase_get(resp, "vnfinstancestatus")
256 resp_data = {"vnfInfo": {"vnfStatus": vnf_status}}
257 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
258 queryVnfResponseSerializer = QueryVnfResponseSerializer(data=resp_data)
259 if not queryVnfResponseSerializer.is_valid():
260 raise Exception(queryVnfResponseSerializer.errors)
261 return Response(data=queryVnfResponseSerializer.data, status=status.HTTP_200_OK)
262 except Exception as e:
263 logger.error("Error occurred when querying VNF information,error:%s", e.message)
264 logger.error(traceback.format_exc())
265 return Response(data={'error': 'QueryVnf expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
268 class JobView(APIView):
269 @swagger_auto_schema(
271 openapi.Parameter('responseId',
274 type=openapi.TYPE_INTEGER
278 status.HTTP_200_OK: JobQueryRespSerializer(),
279 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
282 def get(self, request, vnfmid, jobid):
284 logger.debug("[%s] request.data=%s", fun_name(), request.data)
285 ret = get_vnfminfo_from_nslcm(vnfmid)
287 raise Exception(ret[1])
289 vnfm_info = json.JSONDecoder().decode(ret[1])
290 logger.debug("[%s] vnfm_info=%s", fun_name(), vnfm_info)
291 operation_status_url = '/v1/jobs/{jobId}?NFVOID={nfvoId}&VNFMID={vnfmId}&ResponseID={responseId}'
292 responseId = ignorcase_get(request.GET, 'responseId')
293 query_url = operation_status_url.format(jobId=jobid, nfvoId=1, vnfmId=vnfmid, responseId=responseId)
294 ret = restcall.call_req(
295 base_url=ignorcase_get(vnfm_info, 'url'),
296 user=ignorcase_get(vnfm_info, 'userName'),
297 passwd=ignorcase_get(vnfm_info, 'password'),
298 auth_type=restcall.rest_no_auth,
304 raise Exception(ret[1])
306 resp_data = json.JSONDecoder().decode(ret[1])
307 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
308 jobQueryRespSerializer = JobQueryRespSerializer(data=resp_data)
309 if not jobQueryRespSerializer.is_valid():
310 raise Exception(jobQueryRespSerializer.errors)
312 return Response(data=jobQueryRespSerializer.data, status=status.HTTP_200_OK)
313 except Exception as e:
314 logger.error("Error occurred when getting operation status information,error:%s", e.message)
315 logger.error(traceback.format_exc())
316 return Response(data={'error': 'QueryJob expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
319 class GrantVnf(APIView):
320 @swagger_auto_schema(
321 request_body=GrantReqSerializer(),
323 status.HTTP_201_CREATED: GrantRespSerializer(),
324 status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
327 def put(self, request):
328 logger.debug("=====GrantVnf=====")
330 logger.debug("request.data = %s", request.data)
331 grantReqSerializer = GrantReqSerializer(data=request.data)
332 if not grantReqSerializer.is_valid():
333 raise Exception(grantReqSerializer.errors)
335 logger.debug("grantReqSerializer.data = %s", grantReqSerializer.data)
337 "vnfInstanceId": ignorcase_get(grantReqSerializer.data, "vnfistanceid"),
338 "vnfDescriptorId": "",
341 "vnfmid": ignorcase_get(grantReqSerializer.data, "vnfmid"),
342 "vimid": ignorcase_get(grantReqSerializer.data, "vimid"),
343 "tenant": ignorcase_get(grantReqSerializer.data, "tenant")
346 if ignorcase_get(grantReqSerializer.data, "operationright") == 0:
347 req_data["lifecycleOperation"] = "Instantiate"
348 for vm in ignorcase_get(grantReqSerializer.data, "vmlist"):
349 for i in range(int(ignorcase_get(vm, "VMNumber"))):
350 req_data["addresource"].append(
353 "resourceDefinitionId": i,
354 "vdu": ignorcase_get(vm, "VMFlavor"),
355 "vimid": ignorcase_get(vm, "vimid"),
356 "tenant": ignorcase_get(vm, "tenant")})
358 logger.debug("req_data=%s", req_data)
359 ret = req_by_msb('api/nslcm/v1/ns/grantvnf', "POST", content=json.JSONEncoder().encode(req_data))
360 logger.info("ret = %s", ret)
362 raise Exception(ret[1])
364 resp = json.JSONDecoder().decode(ret[1])
366 'vimid': ignorcase_get(resp['vim'], 'vimid'),
367 'tenant': ignorcase_get(ignorcase_get(resp['vim'], 'accessinfo'), 'tenant')
369 logger.debug("[%s]resp_data=%s", fun_name(), resp_data)
370 grantRespSerializer = GrantRespSerializer(data=resp_data)
371 if not grantRespSerializer.is_valid():
372 raise Exception(grantRespSerializer.errors)
374 logger.debug("grantRespSerializer.data=%s", grantRespSerializer.data)
375 return Response(data=grantRespSerializer.data, status=status.HTTP_201_CREATED)
376 except Exception as e:
377 logger.error("Error occurred in Grant VNF, error: %s", e.message)
378 logger.error(traceback.format_exc())
379 return Response(data={'error': 'Grant expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
382 class Notify(APIView):
383 @swagger_auto_schema(
384 request_body=NotifyReqSerializer(),
386 status.HTTP_200_OK: 'Successfully',
387 status.HTTP_500_INTERNAL_SERVER_ERROR: 'Internal error'
390 def post(self, request):
392 logger.debug("[%s]request.data = %s", fun_name(), request.data)
393 notifyReqSerializer = NotifyReqSerializer(data=request.data)
394 if not notifyReqSerializer.is_valid():
395 raise Exception(notifyReqSerializer.errors)
397 logger.debug("[%s]notifyReqSerializer.data = %s", fun_name(), notifyReqSerializer.data)
400 "vnfInstanceId": ignorcase_get(notifyReqSerializer.data, "vnfinstanceid"),
401 "vnfmId": ignorcase_get(notifyReqSerializer.data, "vnfmid"),
402 "vimId": ignorcase_get(notifyReqSerializer.data, "vimid"),
403 "operation": ignorcase_get(notifyReqSerializer.data, "EventType"),
407 "affectedVirtualStorage": [],
411 extension = ignorcase_get(notifyReqSerializer.data, "extension")
412 openo_notification = ignorcase_get(extension, "openo_notification")
413 if openo_notification:
414 affectedvnfcs = ignorcase_get(openo_notification, "affectedVnfc")
415 affectedvls = ignorcase_get(openo_notification, "affectedvirtuallink")
416 affectedcps = ignorcase_get(openo_notification, "affectedCp")
417 vnfdmodule = ignorcase_get(openo_notification, "vnfdmodule")
419 affectedvnfcs = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvnfc")
420 affectedvls = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedvl")
421 affectedcps = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "affectedcp")
422 vnfdmodule = ignorcase_get(ignorcase_get(notifyReqSerializer.data, "extension"), "vnfdmodule")
424 req_data["vnfdmodule"] = vnfdmodule
426 for affectedvnfc in affectedvnfcs:
427 req_data["affectedVnfc"].append({
428 "vnfcInstanceId": ignorcase_get(affectedvnfc, "vnfcInstanceId"),
429 "vduId": ignorcase_get(affectedvnfc, "vduId"),
430 "changeType": ignorcase_get(affectedvnfc, "changeType"),
431 "vimId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "vimId"),
432 "vmId": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceId"),
433 "vmName": ignorcase_get(ignorcase_get(affectedvnfc, "computeResource"), "resourceName")
436 for affectedvl in affectedvls:
437 req_data["affectedVl"].append({
438 "vlInstanceId": ignorcase_get(affectedvl, "virtualLinkInstanceId"),
439 "changeType": ignorcase_get(affectedvl, "changeType"),
440 "vimId": ignorcase_get(ignorcase_get(affectedvl, "networkResource"), "vimId"),
441 "vldId": ignorcase_get(affectedvl, "virtuallinkdescid"),
443 "resourceType": "network",
444 "resourceId": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourceid"),
445 "resourceName": ignorcase_get(ignorcase_get(affectedvl, "networkresource"), "resourcename")
449 for affectedcp in affectedcps:
450 req_data["affectedCp"].append(affectedcp)
452 vnfmid = ignorcase_get(req_data, 'vnfmId')
453 vnfInstanceId = ignorcase_get(req_data, 'vnfinstanceid')
454 notify_url = 'api/nslcm/v1/ns/%s/vnfs/%s/Notify' % (vnfmid, vnfInstanceId)
455 logger.debug("notify_url = %s", notify_url)
456 logger.debug("req_data = %s", req_data)
457 ret = req_by_msb(notify_url, "POST", content=json.JSONEncoder().encode(req_data))
459 logger.debug("[%s]data = %s", fun_name(), ret)
461 raise Exception(ret[1])
463 return Response(data=None, status=status.HTTP_200_OK)
464 except Exception as e:
465 logger.error("Error occurred in LCM notification,error: %s", e.message)
466 logger.error(traceback.format_exc())
467 return Response(data={'error': 'Notify expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
470 class Scale(APIView):
471 @swagger_auto_schema(
472 request_body=ScaleReqSerializer(),
474 status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
475 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
478 def post(self, request, vnfmid, vnfInstanceId):
479 logger.debug("====scale_vnf===")
481 logger.debug("request.data = %s", request.data)
482 logger.debug("requested_url = %s", request.get_full_path())
483 scaleReqSerializer = ScaleReqSerializer(data=request.data)
484 if not scaleReqSerializer.is_valid():
485 raise Exception(scaleReqSerializer.errors)
487 ret = get_vnfminfo_from_nslcm(vnfmid)
489 raise Exception(ret[1])
491 vnfm_info = json.JSONDecoder().decode(ret[1])
492 scale_type = ignorcase_get(scaleReqSerializer.data, "type")
493 aspect_id = ignorcase_get(scaleReqSerializer.data, "aspectId")
494 number_of_steps = ignorcase_get(scaleReqSerializer.data, "numberOfSteps")
498 'scaletype': '0' if scale_type == 'SCALE_OUT' else '1',
500 'VMNumber': number_of_steps,
501 'VMFlavor': aspect_id
506 logger.debug("data = %s", data)
507 ret = restcall.call_req(
508 base_url=ignorcase_get(vnfm_info, "url"),
509 user=ignorcase_get(vnfm_info, "userName"),
510 passwd=ignorcase_get(vnfm_info, "password"),
511 auth_type=restcall.rest_no_auth,
512 resource='/v1/vnfs/{vnfInstanceID}/scale'.format(vnfInstanceID=vnfInstanceId),
514 content=json.JSONEncoder().encode(data))
515 logger.debug("ret=%s", ret)
517 raise Exception('scale error')
519 scaleRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
520 if not scaleRespSerializer.is_valid():
521 raise Exception(scaleRespSerializer.errors)
523 logger.debug("scaleRespSerializer.data=%s", scaleRespSerializer.data)
524 return Response(data=scaleRespSerializer.data, status=status.HTTP_202_ACCEPTED)
525 except Exception as e:
526 logger.error("Error occurred when scaling VNF,error:%s", e.message)
527 logger.error(traceback.format_exc())
528 return Response(data={'error': 'Scale expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
532 @swagger_auto_schema(
533 request_body=HealReqSerializer(),
535 status.HTTP_202_ACCEPTED: InstScaleHealRespSerializer(),
536 status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal error"
539 def post(self, request, vnfmid, vnfInstanceId):
540 logger.debug("====heal_vnf===")
542 logger.debug("request.data = %s", request.data)
543 logger.debug("requested_url = %s", request.get_full_path())
544 healReqSerializer = HealReqSerializer(data=request.data)
545 if not healReqSerializer.is_valid():
546 raise Exception(healReqSerializer.errors)
548 logger.debug("healReqSerializer.data = %s", healReqSerializer.data)
549 logger.debug("vnfmid = %s", vnfmid)
550 ret = get_vnfminfo_from_nslcm(vnfmid)
552 raise Exception(ret[1])
554 vnfm_info = json.JSONDecoder().decode(ret[1])
556 "action": ignorcase_get(healReqSerializer.data, 'action'),
557 "lifecycleoperation": "operate",
561 affectedvm = ignorcase_get(healReqSerializer.data, 'affectedvm')
562 if isinstance(affectedvm, list):
563 req_data['affectedvm'] = affectedvm
565 req_data['affectedvm'].append(affectedvm)
567 logger.debug("req_data = %s", req_data)
568 ret = restcall.call_req(
569 base_url=ignorcase_get(vnfm_info, "url"),
570 user=ignorcase_get(vnfm_info, "userName"),
571 passwd=ignorcase_get(vnfm_info, "password"),
572 auth_type=restcall.rest_no_auth,
573 resource='/api/v1/nf_m_i/nfs/{vnfInstanceID}/vms/operation'.format(vnfInstanceID=vnfInstanceId),
575 content=json.JSONEncoder().encode(req_data))
576 logger.debug("ret=%s", ret)
578 raise Exception('heal error')
580 healRespSerializer = InstScaleHealRespSerializer(data=json.JSONDecoder().decode(ret[1]))
581 if not healRespSerializer.is_valid():
582 raise Exception(healRespSerializer.errors)
584 logger.debug("healRespSerializer.data=%s", healRespSerializer.data)
585 return Response(data=healRespSerializer.data, status=status.HTTP_202_ACCEPTED)
586 except Exception as e:
587 logger.error("Error occurred when healing VNF,error:%s", e.message)
588 logger.error(traceback.format_exc())
589 return Response(data={'error': 'Heal expection'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
592 def get_vdus(nf_model, aspect_id):
593 associated_group = ''
595 vnf_flavours = nf_model['vnf_flavours']
596 for vnf_flaour in vnf_flavours:
597 scaling_aspects = vnf_flaour['scaling_aspects']
598 for aspect in scaling_aspects:
599 if aspect_id == aspect['id']:
600 associated_group = aspect['associated_group']
602 if not associated_group:
603 logger.error('Cannot find the corresponding element group')
604 raise Exception('Cannot find the corresponding element group')
605 for element_group in nf_model['element_groups']:
606 if element_group['group_id'] == associated_group:
607 members = element_group['members']
609 logger.error('Cannot find the corresponding members')
610 raise Exception('Cannot find the corresponding members')
614 class SampleList(APIView):
615 @swagger_auto_schema(
617 status.HTTP_200_OK: 'Successfully'})
618 def get(self, request):
620 return Response({"status": "active"})
623 class Subscribe(APIView):
624 def get(self, request):
625 logger.debug("====Subscribe get====")
628 "subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657",
633 "notificationuri": " https://127.0.0.1:80/v2/vnfm/vnfds/notification",
636 return Response(data=resp_data, status=status.HTTP_200_OK)
638 def post(self, request):
639 logger.debug("====Subscribe post====")
640 resp_data = {"subscribeid": "cdbddb00-452c-11e9-91e8-acc860114657"}
641 return Response(data=resp_data, status=status.HTTP_201_CREATED)
644 class SubscribeDetail(APIView):
645 def delete(self, request, subscribeId):
646 logger.debug("====SubscribeDetail delete %s====", subscribeId)
647 return Response(status=status.HTTP_204_NO_CONTENT)
650 class VnfPkgs(APIView):
651 def get(self, request):
652 logger.debug("====VnfPkgs get====")
655 "packageid": "924fc980-4530-11e9-ae68-acc860114657",
658 "vnfdfile": "MRP6600_FS_SRIOV_4NIC_200W.zip",
659 "imagefiles": ["MRP6600_FS_SRIOV_MRPISU_IMGV500R008C20SPC030T.tar"],
660 "swfiles": ["MRP6600_SRV_V500R008C20SPC030T.tar"],
661 "description": "This is a service for vCPE.",
664 return Response(data=resp_data, status=status.HTTP_200_OK)