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