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, CpsInfoSerializer, SubnetInfoSerializer, \
  30     NetworkInfoSerializer, FlavorInfoSerializer, VmInfoSerializer
  31
  32 logger = logging.getLogger(__name__)
  33
  34
  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)
  39     try:
  40         vnf_inst = NfInstModel.objects.filter(nfinstid=vnf_inst_id)
  41         if not vnf_inst:
  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)
  49
  50
  51 def fill_resp_data(vnf):
  52     logger.info('Get the StorageInstModel of list')
  53     storage_inst = StorageInstModel.objects.filter(instid=vnf.nfinstid)
  54     arr = []
  55     for s in storage_inst:
  56         storage = {
  57             "virtualStorageInstanceId": s.storageid,
  58             "virtualStorageDescId": s.storagetype,
  59             "storageResource": {
  60                 "vimId": s.vimid,
  61                 "resourceId": s.resouceid
  62             }
  63         }
  64         arr.append(storage)
  65     logger.info('Get the VLInstModel of list.')
  66     vl_inst = VLInstModel.objects.filter(ownerid=vnf.nfinstid)
  67     vl_arr = []
  68     for v in vl_inst:
  69         net = NetworkInstModel.objects.filter(networkid=v.relatednetworkid)
  70         if not net:
  71             raise VNFRESException('NetworkInst(%s) does not exist.' % v.relatednetworkid)
  72         v_dic = {
  73             "virtualLinkInstanceId": v.vlinstanceid,
  74             "virtualLinkDescId": v.vldid,
  75             "networkResource": {
  76                 "vimId": net[0].vimid,
  77                 "resourceId": net[0].resouceid
  78             }
  79         }
  80         vl_arr.append(v_dic)
  81     logger.info('Get VNFCInstModel of list.')
  82     vnfc_insts = VNFCInstModel.objects.filter(instid=vnf.nfinstid)
  83     vnfc_arr = []
  84     for vnfc in vnfc_insts:
  85         vm = VmInstModel.objects.filter(vmid=vnfc.vmid)
  86         if not vm:
  87             raise VNFRESException('VmInst(%s) does not exist.' % vnfc.vmid)
  88         storage = StorageInstModel.objects.filter(ownerid=vm[0].vmid)
  89         if not storage:
  90             raise VNFRESException('StorageInst(%s) does not exist.' % vm[0].vmid)
  91         vnfc_dic = {
  92             "vnfcInstanceId": vnfc.vnfcinstanceid,
  93             "vduId": vnfc.vduid,
  94             "computeResource": {
  95                 "vimId": vm[0].vimid,
  96                 "resourceId": vm[0].resouceid
  97             },
  98             "storageResourceIds": [s.storageid for s in storage]
  99         }
 100         vnfc_arr.append(vnfc_dic)
 101     logger.info('Get the VimInstModel of list.')
 102     vms = VmInstModel.objects.filter(instid=vnf.nfinstid)
 103     vm_arr = []
 104     # The 'vimInfoId' and 'vimId' each value are same
 105     for vm in vms:
 106         vm_dic = {
 107             "vmid": vm.vmid,
 108             "vimid": vm.vimid,
 109             "tenant": vm.tenant,
 110             "resouceid": vm.resouceid,
 111             "vmname": vm.vmname,
 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,
 123             "instid": vm.instid,
 124             "nodeId": vm.nodeId
 125         }
 126         vm_arr.append(vm_dic)
 127
 128     resp_data = {
 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,
 143             "scaleStatus": [],
 144             "extCpInfo": [],
 145             "extVirtualLink": [],
 146             "monitoringParameters": {},
 147             "localizationLanguage": vnf.localizationLanguage,
 148             "vmInfo": vm_arr,
 149             "vnfcResourceInfo": vnfc_arr,
 150             "virtualLinkResourceInfo": vl_arr,
 151             "virtualStorageResourceInfo": arr
 152         },
 153         "metadata": vnf.input_params,
 154         "extensions": vnf.vnfd_model
 155     }
 156     return resp_data
 157
 158
 159 @api_view(http_method_names=['GET'])
 160 def get_vnfs(request):
 161     logger.debug("Query all the vnfs[%s]", fun_name())
 162     try:
 163         vnf_insts = NfInstModel.objects.all()
 164         if not vnf_insts:
 165             return Response(data={'error': 'Vnfs does not exist'}, status=status.HTTP_404_NOT_FOUND)
 166         arr = []
 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)
 174
 175
 176 class getVms(APIView):
 177     @swagger_auto_schema(
 178         responses={
 179             status.HTTP_200_OK: VmInfoSerializer(),
 180             status.HTTP_404_NOT_FOUND: 'Vms does not exist',
 181             status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 182     def get(self, request, vnfInstanceId):
 183         logger.debug("Query all the vms by vnfInstanceId[%s]", fun_name())
 184         try:
 185             vms = VmInstModel.objects.filter(instid=vnfInstanceId)
 186             if not vms:
 187                 return Response(data={'error': 'Vms does not exist'}, status=status.HTTP_404_NOT_FOUND)
 188             arr = []
 189             for vm in vms:
 190                 arr.append(fill_vms_data(vm))
 191
 192             vmInfoSerializer = VmInfoSerializer(data={'resp_data': arr})
 193             isValid = vmInfoSerializer.is_valid()
 194             if not isValid:
 195                 raise Exception(vmInfoSerializer.errors)
 196
 197             return Response(data=vmInfoSerializer.data, status=status.HTTP_200_OK)
 198         except Exception as e:
 199             logger.error(e.message)
 200             logger.error(traceback.format_exc())
 201             return Response(data={'error': 'Failed to get Vms'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 202
 203
 204 def fill_vms_data(vm):
 205     vms_data = {
 206         "vmid": vm.vmid,
 207         "vimid": vm.vimid,
 208         "resouceid": vm.resouceid,
 209         "insttype": vm.insttype,
 210         "instid": vm.instid,
 211         "vmname": vm.vmname,
 212         "operationalstate": vm.operationalstate,
 213         "tenant": vm.tenant,
 214         "is_predefined": vm.is_predefined,
 215         "security_groups": vm.security_groups,
 216         "flavor_id": vm.flavor_id,
 217         "availability_zone": vm.availability_zone,
 218         "server_group": vm.server_group,
 219         "volume_array": vm.volume_array,
 220         "metadata": vm.metadata,
 221         "nic_array": vm.nic_array
 222     }
 223     return vms_data
 224
 225
 226 class getFlavors(APIView):
 227     @swagger_auto_schema(
 228         responses={
 229             status.HTTP_200_OK: FlavorInfoSerializer(),
 230             status.HTTP_404_NOT_FOUND: 'Flavours does not exist',
 231             status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 232     def get(self, request, vnfInstanceId):
 233         logger.debug("Query all the flavors by vnfInstanceId[%s]", fun_name())
 234         try:
 235             flavours = FlavourInstModel.objects.filter(instid=vnfInstanceId)
 236             if not flavours:
 237                 return Response(data={'error': 'Flavours does not exist'}, status=status.HTTP_404_NOT_FOUND)
 238             arr = []
 239             for flavour in flavours:
 240                 arr.append(fill_flavours_data(flavour))
 241
 242             flavorInfoSerializer = FlavorInfoSerializer(data={'resp_data': arr})
 243             isValid = flavorInfoSerializer.is_valid()
 244             if not isValid:
 245                 raise Exception(flavorInfoSerializer.errors)
 246
 247             return Response(data=flavorInfoSerializer.data, status=status.HTTP_200_OK)
 248         except Exception as e:
 249             logger.error(e.message)
 250             logger.error(traceback.format_exc())
 251             return Response(data={'error': 'Failed to get flavours'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 252
 253
 254 def fill_flavours_data(f):
 255     flavours_data = {
 256         "flavourid": f.flavourid,
 257         "name": f.name,
 258         "vcpu": f.vcpu,
 259         "memory": f.memory,
 260         "extraspecs": f.extraspecs,
 261         "instid": f.instid,
 262         "tenant": f.tenant,
 263         "vimid": f.vimid,
 264         "resouceid": f.resouceid,
 265         "create_time": f.create_time
 266     }
 267     return flavours_data
 268
 269
 270 class getNetworks(APIView):
 271     @swagger_auto_schema(
 272         responses={
 273             status.HTTP_200_OK: NetworkInfoSerializer(),
 274             status.HTTP_404_NOT_FOUND: 'Networks does not exist',
 275             status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 276     def get(self, request, vnfInstanceId):
 277         logger.debug("Query all the networks by vnfInstanceId[%s]", fun_name())
 278         try:
 279             networks = NetworkInstModel.objects.filter(instid=vnfInstanceId)
 280             if not networks:
 281                 return Response(data={'error': 'Networks does not exist'}, status=status.HTTP_404_NOT_FOUND)
 282             arr = []
 283             for network in networks:
 284                 arr.append(fill_networks_data(network))
 285
 286             networkInfoSerializer = NetworkInfoSerializer(data={'resp_data': arr})
 287             isValid = networkInfoSerializer.is_valid()
 288             if not isValid:
 289                 raise Exception(networkInfoSerializer.errors)
 290
 291             return Response(data=networkInfoSerializer.data, status=status.HTTP_200_OK)
 292         except Exception as e:
 293             logger.error(e.message)
 294             logger.error(traceback.format_exc())
 295             return Response(data={'error': 'Failed to get networks'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 296
 297
 298 def fill_networks_data(network):
 299     networks_data = {
 300         "networkid": network.networkid,
 301         "vimid": network.vimid,
 302         "resouceid": network.resouceid,
 303         "insttype": network.insttype,
 304         "instid": network.instid,
 305         "name": network.name
 306     }
 307     return networks_data
 308
 309
 310 class getSubnets(APIView):
 311     @swagger_auto_schema(
 312         responses={
 313             status.HTTP_200_OK: SubnetInfoSerializer(),
 314             status.HTTP_404_NOT_FOUND: 'Subnets does not exist',
 315             status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 316     def get(self, request, vnfInstanceId):
 317         logger.debug("Query all the subnets by vnfInstanceId[%s]", fun_name())
 318         try:
 319             subnets = SubNetworkInstModel.objects.filter(instid=vnfInstanceId)
 320             if not subnets:
 321                 return Response(data={'error': 'Subnets does not exist'}, status=status.HTTP_404_NOT_FOUND)
 322             arr = []
 323             for subnet in subnets:
 324                 arr.append(fill_subnets_data(subnet))
 325             subnetInfoSerializer = SubnetInfoSerializer(data={'resp_data': arr})
 326             isValid = subnetInfoSerializer.is_valid()
 327             if not isValid:
 328                 raise Exception(subnetInfoSerializer.errors)
 329
 330             return Response(data=subnetInfoSerializer.data, status=status.HTTP_200_OK)
 331         except Exception as e:
 332             logger.error(e.message)
 333             logger.error(traceback.format_exc())
 334             return Response(data={'error': 'Failed to get subnets'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 335
 336
 337 def fill_subnets_data(subnet):
 338     subnets_data = {
 339         "subnetworkid": subnet.subnetworkid,
 340         "vimid": subnet.vimid,
 341         "resouceid": subnet.resouceid,
 342         "networkid": subnet.networkid,
 343         "insttype": subnet.insttype,
 344         "instid": subnet.instid,
 345         "name": subnet.name,
 346         "cidr": subnet.cidr
 347     }
 348     return subnets_data
 349
 350
 351 class getCps(APIView):
 352     @swagger_auto_schema(
 353         responses={
 354             status.HTTP_200_OK: CpsInfoSerializer(),
 355             status.HTTP_404_NOT_FOUND: 'Cps does not exist',
 356             status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 357     def get(self, request, vnfInstanceId):
 358         logger.debug("Query all the cps by vnfInstanceId[%s]", fun_name())
 359         try:
 360             cps = CPInstModel.objects.filter(ownerid=vnfInstanceId)
 361             if not cps:
 362                 return Response(data={'error': 'Cps does not exist'}, status=status.HTTP_404_NOT_FOUND)
 363             arr = []
 364             for cp in cps:
 365                 arr.append(fill_cps_data(cp))
 366             cpInfoSerializer = CpsInfoSerializer(data={'resp_data': arr})
 367             isValid = cpInfoSerializer.is_valid()
 368             if not isValid:
 369                 raise Exception(cpInfoSerializer.errors)
 370
 371             return Response(data=cpInfoSerializer.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 cps'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 376
 377
 378 def fill_cps_data(cp):
 379     cps_data = {
 380         "cpinstanceid": cp.cpinstanceid,
 381         "cpdid": cp.cpdid,
 382         "cpinstancename": cp.cpinstancename,
 383         "vlinstanceid": cp.vlinstanceid,
 384         "ownertype": cp.ownertype,
 385         "ownerid": cp.ownerid,
 386         "relatedtype": cp.relatedtype
 387     }
 388     return cps_data
 389
 390
 391 class getVolumes(APIView):
 392     @swagger_auto_schema(
 393         responses={
 394             status.HTTP_200_OK: VolumeInfoSerializer(),
 395             status.HTTP_404_NOT_FOUND: 'Volumes does not exist',
 396             status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
 397     def get(self, request, vnfInstanceId):
 398         logger.debug("Query all the volumes by vnfInstanceId[%s]", fun_name())
 399         try:
 400             volumes = StorageInstModel.objects.filter(instid=vnfInstanceId)
 401             if not volumes:
 402                 return Response(data={'error': 'Volumes does not exist'}, status=status.HTTP_404_NOT_FOUND)
 403             arr = []
 404             for v in volumes:
 405                 arr.append(fill_volumes_data(v))
 406             volumeSerializer = VolumeInfoSerializer(data={'resp_data': arr})
 407             isValid = volumeSerializer.is_valid()
 408             if not isValid:
 409                 raise Exception(volumeSerializer.errors)
 410
 411             return Response(data=volumeSerializer.data, status=status.HTTP_200_OK)
 412         except Exception as e:
 413             logger.error(e.message)
 414             logger.error(traceback.format_exc())
 415             return Response(data={'error': 'Failed to get volumes'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 416
 417
 418 def fill_volumes_data(v):
 419     volumes_data = {
 420         "storageid": v.storageid,
 421         "vimid": v.vimid,
 422         "resouceid": v.resouceid,
 423         "insttype": v.insttype,
 424         "instid": v.instid,
 425         "storagetype": v.storagetype,
 426         "size": v.size
 427     }
 428     return volumes_data