res/res/resources/views.py

   1 # Copyright 2017 ZTE Corporation.
   2 #
   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
   6 #
   7 #         http://www.apache.org/licenses/LICENSE-2.0
   8 #
   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.
  14
  15 import logging
  16 import traceback
  17
  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
  23
  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, NoneSerializer, CpsInfoSerializer
  30
  31 logger = logging.getLogger(__name__)
  32
  33
  34 @api_view(http_method_names=['GET'])
  35 def get_vnf(request, *args, **kwargs):
  36     vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
  37     logger.debug("[%s]vnf_inst_id=%s", fun_name(), vnf_inst_id)
  38     try:
  39         vnf_inst = NfInstModel.objects.filter(nfinstid=vnf_inst_id)
  40         if not vnf_inst:
  41             return Response(data={'error': 'Vnf(%s) does not exist' % vnf_inst_id}, status=status.HTTP_404_NOT_FOUND)
  42         resp_data = fill_resp_data(vnf_inst[0])
  43         return Response(data=resp_data, status=status.HTTP_200_OK)
  44     except Exception as e:
  45         logger.error(e.message)
  46         logger.error(traceback.format_exc())
  47         return Response(data={'error': 'Failed to get Vnf(%s)' % vnf_inst_id}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  48
  49
  50 def fill_resp_data(vnf):
  51     logger.info('Get the StorageInstModel of list')
  52     storage_inst = StorageInstModel.objects.filter(instid=vnf.nfinstid)
  53     arr = []
  54     for s in storage_inst:
  55         storage = {
  56             "virtualStorageInstanceId": s.storageid,
  57             "virtualStorageDescId": s.storagetype,
  58             "storageResource": {
  59                 "vimId": s.vimid,
  60                 "resourceId": s.resouceid
  61             }
  62         }
  63         arr.append(storage)
  64     logger.info('Get the VLInstModel of list.')
  65     vl_inst = VLInstModel.objects.filter(ownerid=vnf.nfinstid)
  66     vl_arr = []
  67     for v in vl_inst:
  68         net = NetworkInstModel.objects.filter(networkid=v.relatednetworkid)
  69         if not net:
  70             raise VNFRESException('NetworkInst(%s) does not exist.' % v.relatednetworkid)
  71         v_dic = {
  72             "virtualLinkInstanceId": v.vlinstanceid,
  73             "virtualLinkDescId": v.vldid,
  74             "networkResource": {
  75                 "vimId": net[0].vimid,
  76                 "resourceId": net[0].resouceid
  77             }
  78         }
  79         vl_arr.append(v_dic)
  80     logger.info('Get VNFCInstModel of list.')
  81     vnfc_insts = VNFCInstModel.objects.filter(instid=vnf.nfinstid)
  82     vnfc_arr = []
  83     for vnfc in vnfc_insts:
  84         vm = VmInstModel.objects.filter(vmid=vnfc.vmid)
  85         if not vm:
  86             raise VNFRESException('VmInst(%s) does not exist.' % vnfc.vmid)
  87         storage = StorageInstModel.objects.filter(ownerid=vm[0].vmid)
  88         if not storage:
  89             raise VNFRESException('StorageInst(%s) does not exist.' % vm[0].vmid)
  90         vnfc_dic = {
  91             "vnfcInstanceId": vnfc.vnfcinstanceid,
  92             "vduId": vnfc.vduid,
  93             "computeResource": {
  94                 "vimId": vm[0].vimid,
  95                 "resourceId": vm[0].resouceid
  96             },
  97             "storageResourceIds": [s.storageid for s in storage]
  98         }
  99         vnfc_arr.append(vnfc_dic)
 100     logger.info('Get the VimInstModel of list.')
 101     vms = VmInstModel.objects.filter(instid=vnf.nfinstid)
 102     vm_arr = []
 103     # The 'vimInfoId' and 'vimId' each value are same
 104     for vm in vms:
 105         vm_dic = {
 106             "vmid": vm.vmid,
 107             "vimid": vm.vimid,
 108             "tenant": vm.tenant,
 109             "resouceid": vm.resouceid,
 110             "vmname": vm.vmname,
 111             "nic_array": vm.nic_array,
 112             "metadata": vm.metadata,
 113             "volume_array": vm.volume_array,
 114             "server_group": vm.server_group,
 115             "availability_zone": vm.availability_zone,
 116             "flavor_id": vm.flavor_id,
 117             "security_groups": vm.security_groups,
 118             "operationalstate": vm.operationalstate,
 119             "insttype": vm.insttype,
 120             "is_predefined": vm.is_predefined,
 121             "create_time": vm.create_time,
 122             "instid": vm.instid,
 123             "nodeId": vm.nodeId
 124         }
 125         vm_arr.append(vm_dic)
 126
 127     resp_data = {
 128         "vnfInstanceId": vnf.nfinstid,
 129         "vnfInstanceName": vnf.nf_name,
 130         "vnfInstanceDescription": vnf.nf_desc,
 131         "onboardedVnfPkgInfoId": vnf.package_id,
 132         "vnfdId": vnf.vnfdid,
 133         "vnfdVersion": vnf.version,
 134         "vnfSoftwareVersion": vnf.vnfSoftwareVersion,
 135         "vnfProvider": vnf.vendor,
 136         "vnfProductName": vnf.netype,
 137         "vnfConfigurableProperties": {vnf.vnfConfigurableProperties},
 138         "instantiationState": vnf.status,
 139         "instantiatedVnfInfo": {
 140             "flavourId": vnf.flavour_id,
 141             "vnfState": vnf.status,
 142             "scaleStatus": [],
 143             "extCpInfo": [],
 144             "extVirtualLink": [],
 145             "monitoringParameters": {},
 146             "localizationLanguage": vnf.localizationLanguage,
 147             "vmInfo": vm_arr,
 148             "vnfcResourceInfo": vnfc_arr,
 149             "virtualLinkResourceInfo": vl_arr,
 150             "virtualStorageResourceInfo": arr
 151         },
 152         "metadata": vnf.input_params,
 153         "extensions": vnf.vnfd_model
 154     }
 155     return resp_data
 156
 157
 158 @api_view(http_method_names=['GET'])
 159 def get_vnfs(request):
 160     logger.debug("Query all the vnfs[%s]", fun_name())
 161     try:
 162         vnf_insts = NfInstModel.objects.all()
 163         if not vnf_insts:
 164             return Response(data={'error': 'Vnfs does not exist'}, status=status.HTTP_404_NOT_FOUND)
 165         arr = []
 166         for vnf_inst in vnf_insts:
 167             arr.append(fill_resp_data(vnf_inst))
 168         return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
 169     except Exception as e:
 170         logger.error(e.message)
 171         logger.error(traceback.format_exc())
 172         return Response(data={'error': 'Failed to get Vnfs'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 173
 174
 175 @api_view(http_method_names=['GET'])
 176 def get_vms(request, *args, **kwargs):
 177     logger.debug("Query all the vms by vnfInstanceId[%s]", fun_name())
 178     try:
 179         vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
 180         vms = VmInstModel.objects.filter(instid=vnf_inst_id)
 181         if not vms:
 182             return Response(data={'error': 'Vms does not exist'}, status=status.HTTP_404_NOT_FOUND)
 183         arr = []
 184         for vm in vms:
 185             arr.append(fill_vms_data(vm))
 186         return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
 187     except Exception as e:
 188         logger.error(e.message)
 189         logger.error(traceback.format_exc())
 190         return Response(data={'error': 'Failed to get Vms'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 191
 192
 193 def fill_vms_data(vm):
 194     vms_data = {
 195         "vmid": vm.vmid,
 196         "vimid": vm.vimid,
 197         "resouceid": vm.resouceid,
 198         "insttype": vm.insttype,
 199         "instid": vm.instid,
 200         "vmname": vm.vmname,
 201         "operationalstate": vm.operationalstate,
 202         "tenant": vm.tenant,
 203         "is_predefined": vm.is_predefined,
 204         "security_groups": vm.security_groups,
 205         "flavor_id": vm.flavor_id,
 206         "availability_zone": vm.availability_zone,
 207         "server_group": vm.server_group,
 208         "volume_array": vm.volume_array,
 209         "metadata": vm.metadata,
 210         "nic_array": vm.nic_array
 211     }
 212     return vms_data
 213
 214
 215 @api_view(http_method_names=['GET'])
 216 def get_flavors(request, *args, **kwargs):
 217     logger.debug("Query all the flavors by vnfInstanceId[%s]", fun_name())
 218     try:
 219         vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
 220         flavours = FlavourInstModel.objects.filter(instid=vnf_inst_id)
 221         if not flavours:
 222             return Response(data={'error': 'Flavours does not exist'}, status=status.HTTP_404_NOT_FOUND)
 223         arr = []
 224         for flavour in flavours:
 225             arr.append(fill_flavours_data(flavour))
 226         return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
 227     except Exception as e:
 228         logger.error(e.message)
 229         logger.error(traceback.format_exc())
 230         return Response(data={'error': 'Failed to get flavours'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 231
 232
 233 def fill_flavours_data(f):
 234     flavours_data = {
 235         "flavourid": f.flavourid,
 236         "name": f.name,
 237         "vcpu": f.vcpu,
 238         "memory": f.memory,
 239         "extraspecs": f.extraspecs,
 240         "instid": f.instid,
 241         "tenant": f.tenant,
 242         "vimid": f.vimid,
 243         "resouceid": f.resouceid,
 244         "create_time": f.create_time
 245     }
 246     return flavours_data
 247
 248
 249 @api_view(http_method_names=['GET'])
 250 def get_networks(request, *args, **kwargs):
 251     logger.debug("Query all the networks by vnfInstanceId[%s]", fun_name())
 252     try:
 253         vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
 254         networks = NetworkInstModel.objects.filter(instid=vnf_inst_id)
 255         if not networks:
 256             return Response(data={'error': 'Networks does not exist'}, status=status.HTTP_404_NOT_FOUND)
 257         arr = []
 258         for network in networks:
 259             arr.append(fill_networks_data(network))
 260         return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
 261     except Exception as e:
 262         logger.error(e.message)
 263         logger.error(traceback.format_exc())
 264         return Response(data={'error': 'Failed to get networks'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 265
 266
 267 def fill_networks_data(network):
 268     networks_data = {
 269         "networkid": network.networkid,
 270         "vimid": network.vimid,
 271         "resouceid": network.resouceid,
 272         "insttype": network.insttype,
 273         "instid": network.instid,
 274         "name": network.name
 275     }
 276     return networks_data
 277
 278
 279 @api_view(http_method_names=['GET'])
 280 def get_subnets(request, *args, **kwargs):
 281     logger.debug("Query all the subnets by vnfInstanceId[%s]", fun_name())
 282     try:
 283         vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
 284         subnets = SubNetworkInstModel.objects.filter(instid=vnf_inst_id)
 285         if not subnets:
 286             return Response(data={'error': 'Subnets does not exist'}, status=status.HTTP_404_NOT_FOUND)
 287         arr = []
 288         for subnet in subnets:
 289             arr.append(fill_subnets_data(subnet))
 290         return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
 291     except Exception as e:
 292         logger.error(e.message)
 293         logger.error(traceback.format_exc())
 294         return Response(data={'error': 'Failed to get subnets'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 295
 296
 297 def fill_subnets_data(subnet):
 298     subnets_data = {
 299         "subnetworkid": subnet.subnetworkid,
 300         "vimid": subnet.vimid,
 301         "resouceid": subnet.resouceid,
 302         "networkid": subnet.networkid,
 303         "insttype": subnet.insttype,
 304         "instid": subnet.instid,
 305         "name": subnet.name,
 306         "cidr": subnet.cidr
 307     }
 308     return subnets_data
 309
 310
 311 class getCps(APIView):
 312     @swagger_auto_schema(request_body=NoneSerializer(),
 313                          responses={
 314                              status.HTTP_200_OK: CpsInfoSerializer(),
 315                              status.HTTP_404_NOT_FOUND: 'Cps does not exist',
 316                              status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 317     def get(self, request, vnfInstanceId):
 318         logger.debug("Query all the cps by vnfInstanceId[%s]", fun_name())
 319         try:
 320             cps = CPInstModel.objects.filter(ownerid=vnfInstanceId)
 321             if not cps:
 322                 return Response(data={'error': 'Cps does not exist'}, status=status.HTTP_404_NOT_FOUND)
 323             arr = []
 324             for cp in cps:
 325                 arr.append(fill_cps_data(cp))
 326             cpInfoSerializer = CpsInfoSerializer(data={'resp_data': arr})
 327             isValid = cpInfoSerializer.is_valid()
 328             if not isValid:
 329                 raise Exception(cpInfoSerializer.errors)
 330
 331             return Response(data=cpInfoSerializer.data, status=status.HTTP_200_OK)
 332         except Exception as e:
 333             logger.error(e.message)
 334             logger.error(traceback.format_exc())
 335             return Response(data={'error': 'Failed to get cps'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 336
 337
 338 def fill_cps_data(cp):
 339     cps_data = {
 340         "cpinstanceid": cp.cpinstanceid,
 341         "cpdid": cp.cpdid,
 342         "cpinstancename": cp.cpinstancename,
 343         "vlinstanceid": cp.vlinstanceid,
 344         "ownertype": cp.ownertype,
 345         "ownerid": cp.ownerid,
 346         "relatedtype": cp.relatedtype
 347     }
 348     return cps_data
 349
 350
 351 class getVolumes(APIView):
 352     @swagger_auto_schema(request_body=NoneSerializer(),
 353                          responses={
 354                              status.HTTP_200_OK: VolumeInfoSerializer(),
 355                              status.HTTP_404_NOT_FOUND: 'Volumes does not exist',
 356                              status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 357     def get(self, request, vnfInstanceId):
 358         logger.debug("Query all the volumes by vnfInstanceId[%s]", fun_name())
 359         try:
 360             volumes = StorageInstModel.objects.filter(instid=vnfInstanceId)
 361             if not volumes:
 362                 return Response(data={'error': 'Volumes does not exist'}, status=status.HTTP_404_NOT_FOUND)
 363             arr = []
 364             for v in volumes:
 365                 arr.append(fill_volumes_data(v))
 366             volumeSerializer = VolumeInfoSerializer(data={'resp_data': arr})
 367             isValid = volumeSerializer.is_valid()
 368             if not isValid:
 369                 raise Exception(volumeSerializer.errors)
 370
 371             return Response(data=volumeSerializer.data, status=status.HTTP_200_OK)
 372         except Exception as e:
 373             logger.error(e.message)
 374             logger.error(traceback.format_exc())
 375             return Response(data={'error': 'Failed to get volumes'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 376
 377
 378 def fill_volumes_data(v):
 379     volumes_data = {
 380         "storageid": v.storageid,
 381         "vimid": v.vimid,
 382         "resouceid": v.resouceid,
 383         "insttype": v.insttype,
 384         "instid": v.instid,
 385         "storagetype": v.storagetype,
 386         "size": v.size
 387     }
 388     return volumes_data