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