# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
-import json
+
import logging
-import os
import traceback
+from drf_yasg.utils import swagger_auto_schema
from rest_framework import status
from rest_framework.decorators import api_view
from rest_framework.response import Response
from rest_framework.views import APIView
+from res.pub.database.models import NfInstModel, StorageInstModel, NetworkInstModel, VLInstModel, \
+ VNFCInstModel, VmInstModel, FlavourInstModel, SubNetworkInstModel, CPInstModel
from res.pub.exceptions import VNFRESException
-from res.pub.utils.values import ignore_case_get
from res.pub.utils.syscomm import fun_name
-from res.pub.database.models import NfInstModel, StorageInstModel, NetworkInstModel, VLInstModel, \
- VNFCInstModel, VmInstModel, VimModel, VimUserModel, FlavourInstModel, SubNetworkInstModel, CPInstModel
+from res.pub.utils.values import ignore_case_get
+from res.resources.serializers import VolumeInfoSerializer, CpsInfoSerializer, SubnetInfoSerializer, \
+ NetworkInfoSerializer, FlavorInfoSerializer, VmInfoSerializer
logger = logging.getLogger(__name__)
return Response(data={'error': 'Vnf(%s) does not exist' % vnf_inst_id}, status=status.HTTP_404_NOT_FOUND)
resp_data = fill_resp_data(vnf_inst[0])
return Response(data=resp_data, status=status.HTTP_200_OK)
- except:
+ except Exception as e:
+ logger.error(e.message)
logger.error(traceback.format_exc())
return Response(data={'error': 'Failed to get Vnf(%s)' % vnf_inst_id}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
for s in storage_inst:
storage = {
"virtualStorageInstanceId": s.storageid,
- "virtualStorageDescId": s.storageDesc,
+ "virtualStorageDescId": s.storagetype,
"storageResource": {
"vimId": s.vimid,
"resourceId": s.resouceid
if not net:
raise VNFRESException('NetworkInst(%s) does not exist.' % v.relatednetworkid)
v_dic = {
- "virtualLinkInstanceId": v.vlinstanceid,
- "virtualLinkDescId": v.vldid,
- "networkResource": {
- "vimId": net[0].vimid,
- "resourceId": net[0].resouceid
- }
- }
+ "virtualLinkInstanceId": v.vlinstanceid,
+ "virtualLinkDescId": v.vldid,
+ "networkResource": {
+ "vimId": net[0].vimid,
+ "resourceId": net[0].resouceid
+ }
+ }
vl_arr.append(v_dic)
logger.info('Get VNFCInstModel of list.')
- vnfc_insts = VNFCInstModel.objects.filter(nfinstid=vnf.nfinstid)
+ vnfc_insts = VNFCInstModel.objects.filter(instid=vnf.nfinstid)
vnfc_arr = []
for vnfc in vnfc_insts:
vm = VmInstModel.objects.filter(vmid=vnfc.vmid)
if not storage:
raise VNFRESException('StorageInst(%s) does not exist.' % vm[0].vmid)
vnfc_dic = {
- "vnfcInstanceId": vnfc.vnfcinstanceid,
- "vduId": vnfc.vduid,
- "computeResource": {
- "vimId": vm[0].vimid,
- "resourceId": vm[0].resouceid
- },
- "storageResourceIds": [s.storageid for s in storage]
+ "vnfcInstanceId": vnfc.vnfcinstanceid,
+ "vduId": vnfc.vduid,
+ "computeResource": {
+ "vimId": vm[0].vimid,
+ "resourceId": vm[0].resouceid
+ },
+ "storageResourceIds": [s.storageid for s in storage]
}
vnfc_arr.append(vnfc_dic)
logger.info('Get the VimInstModel of list.')
vms = VmInstModel.objects.filter(instid=vnf.nfinstid)
- vim_arr = []
+ vm_arr = []
# The 'vimInfoId' and 'vimId' each value are same
for vm in vms:
- vims = VimModel.objects.filter(vimid=vm.vimid)
- for vim in vims:
- vim_users = VimUserModel.objects.filter(vimid=vim.vimid)
- vim_dic = {
- "vimInfoId": vim.vimid,
- "vimId": vim.vimid,
- "interfaceInfo": {
- "vimType": vim.type,
- "apiVersion": vim.version,
- "protocolType": (vim.apiurl.split(':')[0] if vim.apiurl and vim.apiurl.index(':') else 'http')
- },
- "accessInfo": {
- "tenant": (vim_users[0].defaulttenant if vim_users and vim_users[0].defaulttenant else ''),
- "username": (vim_users[0].username if vim_users and vim_users[0].username else ''),
- "password": (vim_users[0].password if vim_users and vim_users[0].password else '')
- },
- "interfaceEndpoint": vim.apiurl
- }
- vim_arr.append(vim_dic)
+ vm_dic = {
+ "vmid": vm.vmid,
+ "vimid": vm.vimid,
+ "tenant": vm.tenant,
+ "resouceid": vm.resouceid,
+ "vmname": vm.vmname,
+ "nic_array": vm.nic_array,
+ "metadata": vm.metadata,
+ "volume_array": vm.volume_array,
+ "server_group": vm.server_group,
+ "availability_zone": vm.availability_zone,
+ "flavor_id": vm.flavor_id,
+ "security_groups": vm.security_groups,
+ "operationalstate": vm.operationalstate,
+ "insttype": vm.insttype,
+ "is_predefined": vm.is_predefined,
+ "create_time": vm.create_time,
+ "instid": vm.instid,
+ "nodeId": vm.nodeId
+ }
+ vm_arr.append(vm_dic)
resp_data = {
"vnfInstanceId": vnf.nfinstid,
"vnfdVersion": vnf.version,
"vnfSoftwareVersion": vnf.vnfSoftwareVersion,
"vnfProvider": vnf.vendor,
- "vnfProductName": vnf.producttype,
+ "vnfProductName": vnf.netype,
"vnfConfigurableProperties": {vnf.vnfConfigurableProperties},
- "instantiationState": vnf.instantiationState,
+ "instantiationState": vnf.status,
"instantiatedVnfInfo": {
"flavourId": vnf.flavour_id,
"vnfState": vnf.status,
"extVirtualLink": [],
"monitoringParameters": {},
"localizationLanguage": vnf.localizationLanguage,
- "vimInfo": vim_arr,
+ "vmInfo": vm_arr,
"vnfcResourceInfo": vnfc_arr,
"virtualLinkResourceInfo": vl_arr,
"virtualStorageResourceInfo": arr
},
"metadata": vnf.input_params,
- "extensions": vnf.extension
+ "extensions": vnf.vnfd_model
}
return resp_data
for vnf_inst in vnf_insts:
arr.append(fill_resp_data(vnf_inst))
return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
- except:
+ except Exception as e:
+ logger.error(e.message)
logger.error(traceback.format_exc())
return Response(data={'error': 'Failed to get Vnfs'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
-@api_view(http_method_names=['GET'])
-def get_vms(request, *args, **kwargs):
- logger.debug("Query all the vms by vnfInstanceId[%s]", fun_name())
- try:
- vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
- vms = VmInstModel.objects.filter(instid=vnf_inst_id)
- if not vms:
- return Response(data={'error': 'Vms does not exist'}, status=status.HTTP_404_NOT_FOUND)
- arr = []
- for vm in vms:
- arr.append(fill_vms_data(vm))
- return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
- except:
- logger.error(traceback.format_exc())
- return Response(data={'error': 'Failed to get Vms'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+class getVms(APIView):
+ @swagger_auto_schema(
+ responses={
+ status.HTTP_200_OK: VmInfoSerializer(),
+ status.HTTP_404_NOT_FOUND: 'Vms does not exist',
+ status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
+ def get(self, request, vnfInstanceId):
+ logger.debug("Query all the vms by vnfInstanceId[%s]", fun_name())
+ try:
+ vms = VmInstModel.objects.filter(instid=vnfInstanceId)
+ if not vms:
+ return Response(data={'error': 'Vms does not exist'}, status=status.HTTP_404_NOT_FOUND)
+ arr = []
+ for vm in vms:
+ arr.append(fill_vms_data(vm))
+
+ vmInfoSerializer = VmInfoSerializer(data={'resp_data': arr})
+ isValid = vmInfoSerializer.is_valid()
+ if not isValid:
+ raise Exception(vmInfoSerializer.errors)
+
+ return Response(data=vmInfoSerializer.data, status=status.HTTP_200_OK)
+ except Exception as e:
+ logger.error(e.message)
+ logger.error(traceback.format_exc())
+ return Response(data={'error': 'Failed to get Vms'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fill_vms_data(vm):
"instid": vm.instid,
"vmname": vm.vmname,
"operationalstate": vm.operationalstate,
- "zoneid": vm.zoneid,
"tenant": vm.tenant,
- "hostid": vm.hostid,
- "detailinfo": vm.detailinfo,
- "is_predefined": vm.is_predefined
+ "is_predefined": vm.is_predefined,
+ "security_groups": vm.security_groups,
+ "flavor_id": vm.flavor_id,
+ "availability_zone": vm.availability_zone,
+ "server_group": vm.server_group,
+ "volume_array": vm.volume_array,
+ "metadata": vm.metadata,
+ "nic_array": vm.nic_array
}
return vms_data
-@api_view(http_method_names=['GET'])
-def get_flavors(request, *args, **kwargs):
- logger.debug("Query all the flavors by vnfInstanceId[%s]", fun_name())
- try:
- vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
- flavours = FlavourInstModel.objects.filter(instid=vnf_inst_id)
- if not flavours:
- return Response(data={'error': 'Flavours does not exist'}, status=status.HTTP_404_NOT_FOUND)
- arr = []
- for flavour in flavours:
- arr.append(fill_flavours_data(flavour))
- return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
- except:
- logger.error(traceback.format_exc())
- return Response(data={'error': 'Failed to get flavours'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+class getFlavors(APIView):
+ @swagger_auto_schema(
+ responses={
+ status.HTTP_200_OK: FlavorInfoSerializer(),
+ status.HTTP_404_NOT_FOUND: 'Flavours does not exist',
+ status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
+ def get(self, request, vnfInstanceId):
+ logger.debug("Query all the flavors by vnfInstanceId[%s]", fun_name())
+ try:
+ flavours = FlavourInstModel.objects.filter(instid=vnfInstanceId)
+ if not flavours:
+ return Response(data={'error': 'Flavours does not exist'}, status=status.HTTP_404_NOT_FOUND)
+ arr = []
+ for flavour in flavours:
+ arr.append(fill_flavours_data(flavour))
+
+ flavorInfoSerializer = FlavorInfoSerializer(data={'resp_data': arr})
+ isValid = flavorInfoSerializer.is_valid()
+ if not isValid:
+ raise Exception(flavorInfoSerializer.errors)
+
+ return Response(data=flavorInfoSerializer.data, status=status.HTTP_200_OK)
+ except Exception as e:
+ logger.error(e.message)
+ logger.error(traceback.format_exc())
+ return Response(data={'error': 'Failed to get flavours'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fill_flavours_data(f):
"extraspecs": f.extraspecs,
"instid": f.instid,
"tenant": f.tenant,
- "vmid": f.vmid,
+ "vimid": f.vimid,
+ "resouceid": f.resouceid,
"create_time": f.create_time
}
return flavours_data
-@api_view(http_method_names=['GET'])
-def get_networks(request, *args, **kwargs):
- logger.debug("Query all the networks by vnfInstanceId[%s]", fun_name())
- try:
- vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
- networks = NetworkInstModel.objects.filter(instid=vnf_inst_id)
- if not networks:
- return Response(data={'error': 'Networks does not exist'}, status=status.HTTP_404_NOT_FOUND)
- arr = []
- for network in networks:
- arr.append(fill_networks_data(network))
- return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
- except:
- logger.error(traceback.format_exc())
- return Response(data={'error': 'Failed to get networks'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+class getNetworks(APIView):
+ @swagger_auto_schema(
+ responses={
+ status.HTTP_200_OK: NetworkInfoSerializer(),
+ status.HTTP_404_NOT_FOUND: 'Networks does not exist',
+ status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
+ def get(self, request, vnfInstanceId):
+ logger.debug("Query all the networks by vnfInstanceId[%s]", fun_name())
+ try:
+ networks = NetworkInstModel.objects.filter(instid=vnfInstanceId)
+ if not networks:
+ return Response(data={'error': 'Networks does not exist'}, status=status.HTTP_404_NOT_FOUND)
+ arr = []
+ for network in networks:
+ arr.append(fill_networks_data(network))
+
+ networkInfoSerializer = NetworkInfoSerializer(data={'resp_data': arr})
+ isValid = networkInfoSerializer.is_valid()
+ if not isValid:
+ raise Exception(networkInfoSerializer.errors)
+
+ return Response(data=networkInfoSerializer.data, status=status.HTTP_200_OK)
+ except Exception as e:
+ logger.error(e.message)
+ logger.error(traceback.format_exc())
+ return Response(data={'error': 'Failed to get networks'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fill_networks_data(network):
"insttype": network.insttype,
"instid": network.instid,
"name": network.name
- # "tenant": network.tenant,
- # "is_shared": network.is_shared,
- # "is_predefined": network.is_predefined,
- # "desc": network.desc,
- # "vendor": network.vendor,
- # "bandwidth": network.bandwidth,
- # "mtu": network.mtu,
- # "network_type": network.network_type,
- # "segmentid": network.segmentid,
- # "vlantrans": network.vlantrans,
- # "networkqos": network.networkqos
}
return networks_data
-@api_view(http_method_names=['GET'])
-def get_subnets(request, *args, **kwargs):
- logger.debug("Query all the subnets by vnfInstanceId[%s]", fun_name())
- try:
- vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
- subnets = SubNetworkInstModel.objects.filter(instid=vnf_inst_id)
- if not subnets:
- return Response(data={'error': 'Subnets does not exist'}, status=status.HTTP_404_NOT_FOUND)
- arr = []
- for subnet in subnets:
- arr.append(fill_subnets_data(subnet))
- return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
- except:
- logger.error(traceback.format_exc())
- return Response(data={'error': 'Failed to get subnets'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+class getSubnets(APIView):
+ @swagger_auto_schema(
+ responses={
+ status.HTTP_200_OK: SubnetInfoSerializer(),
+ status.HTTP_404_NOT_FOUND: 'Subnets does not exist',
+ status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
+ def get(self, request, vnfInstanceId):
+ logger.debug("Query all the subnets by vnfInstanceId[%s]", fun_name())
+ try:
+ subnets = SubNetworkInstModel.objects.filter(instid=vnfInstanceId)
+ if not subnets:
+ return Response(data={'error': 'Subnets does not exist'}, status=status.HTTP_404_NOT_FOUND)
+ arr = []
+ for subnet in subnets:
+ arr.append(fill_subnets_data(subnet))
+ subnetInfoSerializer = SubnetInfoSerializer(data={'resp_data': arr})
+ isValid = subnetInfoSerializer.is_valid()
+ if not isValid:
+ raise Exception(subnetInfoSerializer.errors)
+
+ return Response(data=subnetInfoSerializer.data, status=status.HTTP_200_OK)
+ except Exception as e:
+ logger.error(e.message)
+ logger.error(traceback.format_exc())
+ return Response(data={'error': 'Failed to get subnets'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fill_subnets_data(subnet):
return subnets_data
-@api_view(http_method_names=['GET'])
-def get_cps(request, *args, **kwargs):
- logger.debug("Query all the cps by vnfInstanceId[%s]", fun_name())
- try:
- vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
- cps = CPInstModel.objects.filter(ownerid=vnf_inst_id)
- if not cps:
- return Response(data={'error': 'Cps does not exist'}, status=status.HTTP_404_NOT_FOUND)
- arr = []
- for cp in cps:
- arr.append(fill_cps_data(cp))
- return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
- except:
- logger.error(traceback.format_exc())
- return Response(data={'error': 'Failed to get cps'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+class getCps(APIView):
+ @swagger_auto_schema(
+ responses={
+ status.HTTP_200_OK: CpsInfoSerializer(),
+ status.HTTP_404_NOT_FOUND: 'Cps does not exist',
+ status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
+ def get(self, request, vnfInstanceId):
+ logger.debug("Query all the cps by vnfInstanceId[%s]", fun_name())
+ try:
+ cps = CPInstModel.objects.filter(ownerid=vnfInstanceId)
+ if not cps:
+ return Response(data={'error': 'Cps does not exist'}, status=status.HTTP_404_NOT_FOUND)
+ arr = []
+ for cp in cps:
+ arr.append(fill_cps_data(cp))
+ cpInfoSerializer = CpsInfoSerializer(data={'resp_data': arr})
+ isValid = cpInfoSerializer.is_valid()
+ if not isValid:
+ raise Exception(cpInfoSerializer.errors)
+
+ return Response(data=cpInfoSerializer.data, status=status.HTTP_200_OK)
+ except Exception as e:
+ logger.error(e.message)
+ logger.error(traceback.format_exc())
+ return Response(data={'error': 'Failed to get cps'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fill_cps_data(cp):
return cps_data
-@api_view(http_method_names=['GET'])
-def get_volumes(request, *args, **kwargs):
- logger.debug("Query all the volumes by vnfInstanceId[%s]", fun_name())
- try:
- vnf_inst_id = ignore_case_get(kwargs, "vnfInstanceId")
- volumes = StorageInstModel.objects.filter(instid=vnf_inst_id)
- if not volumes:
- return Response(data={'error': 'Volumes does not exist'}, status=status.HTTP_404_NOT_FOUND)
- arr = []
- for v in volumes:
- arr.append(fill_volumes_data(v))
- return Response(data={'resp_data': arr}, status=status.HTTP_200_OK)
- except:
- logger.error(traceback.format_exc())
- return Response(data={'error': 'Failed to get volumes'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
+class getVolumes(APIView):
+ @swagger_auto_schema(
+ responses={
+ status.HTTP_200_OK: VolumeInfoSerializer(),
+ status.HTTP_404_NOT_FOUND: 'Volumes does not exist',
+ status.HTTP_500_INTERNAL_SERVER_ERROR: 'internal error'})
+ def get(self, request, vnfInstanceId):
+ logger.debug("Query all the volumes by vnfInstanceId[%s]", fun_name())
+ try:
+ volumes = StorageInstModel.objects.filter(instid=vnfInstanceId)
+ if not volumes:
+ return Response(data={'error': 'Volumes does not exist'}, status=status.HTTP_404_NOT_FOUND)
+ arr = []
+ for v in volumes:
+ arr.append(fill_volumes_data(v))
+ volumeSerializer = VolumeInfoSerializer(data={'resp_data': arr})
+ isValid = volumeSerializer.is_valid()
+ if not isValid:
+ raise Exception(volumeSerializer.errors)
+
+ return Response(data=volumeSerializer.data, status=status.HTTP_200_OK)
+ except Exception as e:
+ logger.error(e.message)
+ logger.error(traceback.format_exc())
+ return Response(data={'error': 'Failed to get volumes'}, status=status.HTTP_500_INTERNAL_SERVER_ERROR)
def fill_volumes_data(v):
"insttype": v.insttype,
"instid": v.instid,
"storagetype": v.storagetype,
- "size": v.size,
- "disktype": v.disktype
+ "size": v.size
}
return volumes_data
-
-
-class SwaggerJsonView(APIView):
- def get(self, request):
- json_file = os.path.join(os.path.dirname(__file__), 'swagger.json')
- f = open(json_file)
- json_data = json.JSONDecoder().decode(f.read())
- f.close()
- return Response(json_data)
Code Review / vfc / gvnfm / vnfres.git / blobdiff