1 # Copyright 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 drf_yasg.utils import swagger_auto_schema
19 from rest_framework import status
20 from rest_framework.decorators import api_view
21 from rest_framework.response import Response
22 from rest_framework.views import APIView
24 from res.pub.database.models import NfInstModel, StorageInstModel, NetworkInstModel, VLInstModel, \
25 VNFCInstModel, VmInstModel, FlavourInstModel, SubNetworkInstModel, CPInstModel
26 from res.pub.exceptions import VNFRESException
27 from res.pub.utils.syscomm import fun_name
28 from res.pub.utils.values import ignore_case_get
29 from res.resources.serializers import VolumeInfoSerializer, CpsInfoSerializer, SubnetInfoSerializer, \
30 NetworkInfoSerializer, FlavorInfoSerializer
32 logger = logging.getLogger(__name__)
35 @api_view(http_method_names=['GET'])
36 def get_vnf(request, *args, **kwargs):
37 vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
38 logger.debug("[%s]vnf_inst_id=%s", fun_name(), vnf_inst_id)
40 vnf_inst = NfInstModel.objects.filter(nfinstid=vnf_inst_id)
42 return Response(data={'error': 'Vnf(%s) does not exist' % vnf_inst_id}, status=status.HTTP_404_NOT_FOUND)
43 resp_data = fill_resp_data(vnf_inst[0])
44 return Response(data=resp_data, status=status.HTTP_200_OK)
45 except Exception as e:
46 logger.error(e.message)
47 logger.error(traceback.format_exc())
48 return Response(data={'error': 'Failed to get Vnf(%s)' % vnf_inst_id}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
51 def fill_resp_data(vnf):
52 logger.info('Get the StorageInstModel of list')
53 storage_inst = StorageInstModel.objects.filter(instid=vnf.nfinstid)
55 for s in storage_inst:
57 "virtualStorageInstanceId": s.storageid,
58 "virtualStorageDescId": s.storagetype,
61 "resourceId": s.resouceid
65 logger.info('Get the VLInstModel of list.')
66 vl_inst = VLInstModel.objects.filter(ownerid=vnf.nfinstid)
69 net = NetworkInstModel.objects.filter(networkid=v.relatednetworkid)
71 raise VNFRESException('NetworkInst(%s) does not exist.' % v.relatednetworkid)
73 "virtualLinkInstanceId": v.vlinstanceid,
74 "virtualLinkDescId": v.vldid,
76 "vimId": net[0].vimid,
77 "resourceId": net[0].resouceid
81 logger.info('Get VNFCInstModel of list.')
82 vnfc_insts = VNFCInstModel.objects.filter(instid=vnf.nfinstid)
84 for vnfc in vnfc_insts:
85 vm = VmInstModel.objects.filter(vmid=vnfc.vmid)
87 raise VNFRESException('VmInst(%s) does not exist.' % vnfc.vmid)
88 storage = StorageInstModel.objects.filter(ownerid=vm[0].vmid)
90 raise VNFRESException('StorageInst(%s) does not exist.' % vm[0].vmid)
92 "vnfcInstanceId": vnfc.vnfcinstanceid,
96 "resourceId": vm[0].resouceid
98 "storageResourceIds": [s.storageid for s in storage]
100 vnfc_arr.append(vnfc_dic)
101 logger.info('Get the VimInstModel of list.')
102 vms = VmInstModel.objects.filter(instid=vnf.nfinstid)
104 # The 'vimInfoId' and 'vimId' each value are same
110 "resouceid": vm.resouceid,
112 "nic_array": vm.nic_array,
113 "metadata": vm.metadata,
114 "volume_array": vm.volume_array,
115 "server_group": vm.server_group,
116 "availability_zone": vm.availability_zone,
117 "flavor_id": vm.flavor_id,
118 "security_groups": vm.security_groups,
119 "operationalstate": vm.operationalstate,
120 "insttype": vm.insttype,
121 "is_predefined": vm.is_predefined,
122 "create_time": vm.create_time,
126 vm_arr.append(vm_dic)
129 "vnfInstanceId": vnf.nfinstid,
130 "vnfInstanceName": vnf.nf_name,
131 "vnfInstanceDescription": vnf.nf_desc,
132 "onboardedVnfPkgInfoId": vnf.package_id,
133 "vnfdId": vnf.vnfdid,
134 "vnfdVersion": vnf.version,
135 "vnfSoftwareVersion": vnf.vnfSoftwareVersion,
136 "vnfProvider": vnf.vendor,
137 "vnfProductName": vnf.netype,
138 "vnfConfigurableProperties": {vnf.vnfConfigurableProperties},
139 "instantiationState": vnf.status,
140 "instantiatedVnfInfo": {
141 "flavourId": vnf.flavour_id,
142 "vnfState": vnf.status,
145 "extVirtualLink": [],
146 "monitoringParameters": {},
147 "localizationLanguage": vnf.localizationLanguage,
149 "vnfcResourceInfo": vnfc_arr,
150 "virtualLinkResourceInfo": vl_arr,
151 "virtualStorageResourceInfo": arr
153 "metadata": vnf.input_params,
154 "extensions": vnf.vnfd_model
159 @api_view(http_method_names=['GET'])
160 def get_vnfs(request):
161 logger.debug("Query all the vnfs[%s]", fun_name())
163 vnf_insts = NfInstModel.objects.all()
165 return Response(data={'error': 'Vnfs does not exist'}, status=status.HTTP_404_NOT_FOUND)
167 for vnf_inst in vnf_insts:
168 arr.append(fill_resp_data(vnf_inst))
169 return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
170 except Exception as e:
171 logger.error(e.message)
172 logger.error(traceback.format_exc())
173 return Response(data={'error': 'Failed to get Vnfs'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
176 @api_view(http_method_names=['GET'])
177 def get_vms(request, *args, **kwargs):
178 logger.debug("Query all the vms by vnfInstanceId[%s]", fun_name())
180 vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
181 vms = VmInstModel.objects.filter(instid=vnf_inst_id)
183 return Response(data={'error': 'Vms does not exist'}, status=status.HTTP_404_NOT_FOUND)
186 arr.append(fill_vms_data(vm))
187 return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
188 except Exception as e:
189 logger.error(e.message)
190 logger.error(traceback.format_exc())
191 return Response(data={'error': 'Failed to get Vms'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
194 def fill_vms_data(vm):
198 "resouceid": vm.resouceid,
199 "insttype": vm.insttype,
202 "operationalstate": vm.operationalstate,
204 "is_predefined": vm.is_predefined,
205 "security_groups": vm.security_groups,
206 "flavor_id": vm.flavor_id,
207 "availability_zone": vm.availability_zone,
208 "server_group": vm.server_group,
209 "volume_array": vm.volume_array,
210 "metadata": vm.metadata,
211 "nic_array": vm.nic_array
216 class getFlavors(APIView):
217 @swagger_auto_schema(
219 status.HTTP_200_OK: FlavorInfoSerializer(),
220 status.HTTP_404_NOT_FOUND: 'Flavours does not exist',
221 status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
222 def get(self, request, vnfInstanceId):
223 logger.debug("Query all the flavors by vnfInstanceId[%s]", fun_name())
225 flavours = FlavourInstModel.objects.filter(instid=vnfInstanceId)
227 return Response(data={'error': 'Flavours does not exist'}, status=status.HTTP_404_NOT_FOUND)
229 for flavour in flavours:
230 arr.append(fill_flavours_data(flavour))
232 flavorInfoSerializer = FlavorInfoSerializer(data={'resp_data': arr})
233 isValid = flavorInfoSerializer.is_valid()
235 raise Exception(flavorInfoSerializer.errors)
237 return Response(data=flavorInfoSerializer.data, status=status.HTTP_200_OK)
238 except Exception as e:
239 logger.error(e.message)
240 logger.error(traceback.format_exc())
241 return Response(data={'error': 'Failed to get flavours'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
244 def fill_flavours_data(f):
246 "flavourid": f.flavourid,
250 "extraspecs": f.extraspecs,
254 "resouceid": f.resouceid,
255 "create_time": f.create_time
260 class getNetworks(APIView):
261 @swagger_auto_schema(
263 status.HTTP_200_OK: NetworkInfoSerializer(),
264 status.HTTP_404_NOT_FOUND: 'Networks does not exist',
265 status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
266 def get(self, request, vnfInstanceId):
267 logger.debug("Query all the networks by vnfInstanceId[%s]", fun_name())
269 networks = NetworkInstModel.objects.filter(instid=vnfInstanceId)
271 return Response(data={'error': 'Networks does not exist'}, status=status.HTTP_404_NOT_FOUND)
273 for network in networks:
274 arr.append(fill_networks_data(network))
276 networkInfoSerializer = NetworkInfoSerializer(data={'resp_data': arr})
277 isValid = networkInfoSerializer.is_valid()
279 raise Exception(networkInfoSerializer.errors)
281 return Response(data=networkInfoSerializer.data, status=status.HTTP_200_OK)
282 except Exception as e:
283 logger.error(e.message)
284 logger.error(traceback.format_exc())
285 return Response(data={'error': 'Failed to get networks'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
288 def fill_networks_data(network):
290 "networkid": network.networkid,
291 "vimid": network.vimid,
292 "resouceid": network.resouceid,
293 "insttype": network.insttype,
294 "instid": network.instid,
300 class getSubnets(APIView):
301 @swagger_auto_schema(
303 status.HTTP_200_OK: SubnetInfoSerializer(),
304 status.HTTP_404_NOT_FOUND: 'Subnets does not exist',
305 status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
306 def get(self, request, vnfInstanceId):
307 logger.debug("Query all the subnets by vnfInstanceId[%s]", fun_name())
309 subnets = SubNetworkInstModel.objects.filter(instid=vnfInstanceId)
311 return Response(data={'error': 'Subnets does not exist'}, status=status.HTTP_404_NOT_FOUND)
313 for subnet in subnets:
314 arr.append(fill_subnets_data(subnet))
315 subnetInfoSerializer = SubnetInfoSerializer(data={'resp_data': arr})
316 isValid = subnetInfoSerializer.is_valid()
318 raise Exception(subnetInfoSerializer.errors)
320 return Response(data=subnetInfoSerializer.data, status=status.HTTP_200_OK)
321 except Exception as e:
322 logger.error(e.message)
323 logger.error(traceback.format_exc())
324 return Response(data={'error': 'Failed to get subnets'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
327 def fill_subnets_data(subnet):
329 "subnetworkid": subnet.subnetworkid,
330 "vimid": subnet.vimid,
331 "resouceid": subnet.resouceid,
332 "networkid": subnet.networkid,
333 "insttype": subnet.insttype,
334 "instid": subnet.instid,
341 class getCps(APIView):
342 @swagger_auto_schema(
344 status.HTTP_200_OK: CpsInfoSerializer(),
345 status.HTTP_404_NOT_FOUND: 'Cps does not exist',
346 status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
347 def get(self, request, vnfInstanceId):
348 logger.debug("Query all the cps by vnfInstanceId[%s]", fun_name())
350 cps = CPInstModel.objects.filter(ownerid=vnfInstanceId)
352 return Response(data={'error': 'Cps does not exist'}, status=status.HTTP_404_NOT_FOUND)
355 arr.append(fill_cps_data(cp))
356 cpInfoSerializer = CpsInfoSerializer(data={'resp_data': arr})
357 isValid = cpInfoSerializer.is_valid()
359 raise Exception(cpInfoSerializer.errors)
361 return Response(data=cpInfoSerializer.data, status=status.HTTP_200_OK)
362 except Exception as e:
363 logger.error(e.message)
364 logger.error(traceback.format_exc())
365 return Response(data={'error': 'Failed to get cps'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
368 def fill_cps_data(cp):
370 "cpinstanceid": cp.cpinstanceid,
372 "cpinstancename": cp.cpinstancename,
373 "vlinstanceid": cp.vlinstanceid,
374 "ownertype": cp.ownertype,
375 "ownerid": cp.ownerid,
376 "relatedtype": cp.relatedtype
381 class getVolumes(APIView):
382 @swagger_auto_schema(
384 status.HTTP_200_OK: VolumeInfoSerializer(),
385 status.HTTP_404_NOT_FOUND: 'Volumes does not exist',
386 status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
387 def get(self, request, vnfInstanceId):
388 logger.debug("Query all the volumes by vnfInstanceId[%s]", fun_name())
390 volumes = StorageInstModel.objects.filter(instid=vnfInstanceId)
392 return Response(data={'error': 'Volumes does not exist'}, status=status.HTTP_404_NOT_FOUND)
395 arr.append(fill_volumes_data(v))
396 volumeSerializer = VolumeInfoSerializer(data={'resp_data': arr})
397 isValid = volumeSerializer.is_valid()
399 raise Exception(volumeSerializer.errors)
401 return Response(data=volumeSerializer.data, status=status.HTTP_200_OK)
402 except Exception as e:
403 logger.error(e.message)
404 logger.error(traceback.format_exc())
405 return Response(data={'error': 'Failed to get volumes'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
408 def fill_volumes_data(v):
410 "storageid": v.storageid,
412 "resouceid": v.resouceid,
413 "insttype": v.insttype,
415 "storagetype": v.storagetype,