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