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