catalog/packages/views/vnf_package_views.py

   1 # Copyright 2018 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
  17 from django.http import StreamingHttpResponse
  18 from drf_yasg.utils import swagger_auto_schema, no_body
  19 from drf_yasg import openapi
  20 from rest_framework import status
  21 from rest_framework.decorators import api_view
  22 from rest_framework.response import Response
  23
  24 from catalog.packages.biz.vnf_package import VnfPackage
  25 from catalog.packages.biz.vnf_package import VnfPkgUploadThread
  26 from catalog.packages.biz.vnf_package import handle_upload_failed
  27 from catalog.packages.biz.vnf_package import parse_vnfd_and_save
  28 from catalog.packages.const import TAG_VNF_PACKAGE_API
  29 from catalog.packages.serializers.create_vnf_pkg_info_req import CreateVnfPkgInfoRequestSerializer
  30 from catalog.packages.serializers.upload_vnf_pkg_from_uri_req import UploadVnfPackageFromUriRequestSerializer
  31 from catalog.packages.serializers.vnf_pkg_info import VnfPkgInfoSerializer
  32 from catalog.packages.serializers.vnf_pkg_infos import VnfPkgInfosSerializer
  33 from .common import validate_data, validate_req_data
  34 from .common import view_safe_call_with_log
  35 from catalog.swagger.views import EtsiCatalogFileAutoSchema
  36
  37 logger = logging.getLogger(__name__)
  38
  39
  40 @swagger_auto_schema(
  41     method="GET",
  42     operation_description="Query multiple VNF package resource",
  43     tags=[TAG_VNF_PACKAGE_API],
  44     request_body=no_body,
  45     responses={
  46         status.HTTP_200_OK: VnfPkgInfosSerializer(),
  47         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
  48                                                                 openapi.Schema(type=openapi.TYPE_STRING))
  49     }
  50 )
  51 @swagger_auto_schema(
  52     method="POST",
  53     operation_description="Create an individual VNF package resource",
  54     tags=[TAG_VNF_PACKAGE_API],
  55     request_body=CreateVnfPkgInfoRequestSerializer,
  56     responses={
  57         status.HTTP_201_CREATED: VnfPkgInfoSerializer(),
  58         status.HTTP_400_BAD_REQUEST: openapi.Response("Bad Request", schema=openapi.Schema(type=openapi.TYPE_STRING)),
  59         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
  60                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
  61     }
  62 )
  63 @api_view(http_method_names=["GET", "POST"])
  64 @view_safe_call_with_log(logger=logger)
  65 def vnf_packages_rc(request):
  66     if request.method == 'GET':
  67         # Query VNF packages information
  68         logger.debug("Query VNF packages> %s" % request.data)
  69         data = VnfPackage().query_multiple()
  70         validate_data(data, VnfPkgInfosSerializer)
  71         return Response(data=data, status=status.HTTP_200_OK)
  72
  73     if request.method == 'POST':
  74         # Create a new individual VNF package resource
  75         logger.debug("Create VNF package> %s" % request.data)
  76         create_vnf_pkg_info_request = validate_req_data(request.data, CreateVnfPkgInfoRequestSerializer)
  77         data = VnfPackage().create_vnf_pkg(create_vnf_pkg_info_request.data)
  78         validate_data(data, VnfPkgInfoSerializer)
  79         return Response(data=data, status=status.HTTP_201_CREATED)
  80
  81
  82 @swagger_auto_schema(
  83     auto_schema=EtsiCatalogFileAutoSchema,
  84     method="GET",
  85     operation_description="Read VNFD of an on-boarded VNF package",
  86     tags=[TAG_VNF_PACKAGE_API],
  87     request_body=no_body,
  88     responses={
  89         status.HTTP_200_OK: openapi.Response('VNFD of an on-boarded VNF package',
  90                                              schema=openapi.Schema(format=openapi.FORMAT_BINARY,
  91                                                                    type=openapi.TYPE_STRING)),
  92         status.HTTP_404_NOT_FOUND: openapi.Response("VNF package does not exist",
  93                                                     schema=openapi.Schema(type=openapi.TYPE_STRING)),
  94         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
  95                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
  96     },
  97     operation_id='VNFD of an on-boarded VNF package'
  98 )
  99 @api_view(http_method_names=["GET"])
 100 @view_safe_call_with_log(logger=logger)
 101 def vnfd_rd(request, **kwargs):
 102     """
 103     Get the VNFD by VNF package id
 104     :param request:
 105     :param kwargs:
 106     :return:
 107     """
 108     vnf_pkg_id = kwargs.get("vnfPkgId")
 109     logger.debug("Read VNFD for  VNF package %s" % vnf_pkg_id)
 110     try:
 111         file_iterator = VnfPackage().download_vnfd(vnf_pkg_id)
 112         return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)
 113     except Exception as e:
 114         logger.error(e)
 115         raise e
 116
 117
 118 @swagger_auto_schema(
 119     method='PUT',
 120     operation_description="Upload VNF package content",
 121     tags=[TAG_VNF_PACKAGE_API],
 122     request_body=no_body,
 123     responses={
 124         status.HTTP_202_ACCEPTED: "Successfully",
 125         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 126                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 127     }
 128 )
 129 @swagger_auto_schema(
 130     auto_schema=EtsiCatalogFileAutoSchema,
 131     method="GET",
 132     operation_description="Fetch VNF package content",
 133     tags=[TAG_VNF_PACKAGE_API],
 134     request_body=no_body,
 135     responses={
 136         status.HTTP_200_OK: openapi.Response('VNF package file',
 137                                              schema=openapi.Schema(format=openapi.FORMAT_BINARY,
 138                                                                    type=openapi.TYPE_STRING)),
 139         status.HTTP_404_NOT_FOUND: openapi.Response("VNF package does not exist",
 140                                                     schema=openapi.Schema(type=openapi.TYPE_STRING)),
 141         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 142                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 143     }
 144 )
 145 @api_view(http_method_names=["PUT", "GET"])
 146 @view_safe_call_with_log(logger=logger)
 147 def package_content_ru(request, **kwargs):
 148     vnf_pkg_id = kwargs.get("vnfPkgId")
 149     if request.method == "PUT":
 150         # Upload a VNF package by providing the content of the VNF package
 151         logger.debug("Upload VNF package %s" % vnf_pkg_id)
 152         files = request.FILES.getlist('file')
 153         try:
 154             local_file_name = VnfPackage().upload(vnf_pkg_id, files[0])
 155             parse_vnfd_and_save(vnf_pkg_id, local_file_name)
 156             return Response(None, status=status.HTTP_202_ACCEPTED)
 157         except Exception as e:
 158             handle_upload_failed(vnf_pkg_id)
 159             raise e
 160
 161     if request.method == "GET":
 162         # Fetch an on-boarded VNF package
 163         file_range = request.META.get('HTTP_RANGE')
 164         file_iterator = VnfPackage().download(vnf_pkg_id, file_range)
 165         return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)
 166
 167
 168 @swagger_auto_schema(
 169     method='POST',
 170     operation_description="Upload VNF package content from uri",
 171     tags=[TAG_VNF_PACKAGE_API],
 172     request_body=UploadVnfPackageFromUriRequestSerializer,
 173     responses={
 174         status.HTTP_202_ACCEPTED: "Successfully",
 175         status.HTTP_400_BAD_REQUEST: openapi.Response("Bad Request", schema=openapi.Schema(type=openapi.TYPE_STRING)),
 176         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 177                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 178     }
 179 )
 180 @api_view(http_method_names=['POST'])
 181 @view_safe_call_with_log(logger=logger)
 182 def upload_from_uri_c(request, **kwargs):
 183     """
 184     Upload a VNF package by providing the address information of the VNF package
 185     :param request:
 186     :param kwargs:
 187     :return:
 188     """
 189     vnf_pkg_id = kwargs.get("vnfPkgId")
 190     try:
 191         upload_vnf_from_uri_request = validate_req_data(request.data,
 192                                                         UploadVnfPackageFromUriRequestSerializer)
 193         VnfPkgUploadThread(upload_vnf_from_uri_request.data, vnf_pkg_id).start()
 194         return Response(None, status=status.HTTP_202_ACCEPTED)
 195     except Exception as e:
 196         handle_upload_failed(vnf_pkg_id)
 197         raise e
 198
 199
 200 @swagger_auto_schema(
 201     method='GET',
 202     operation_description="Query an individual VNF package resource",
 203     tags=[TAG_VNF_PACKAGE_API],
 204     request_body=no_body,
 205     responses={
 206         status.HTTP_200_OK: VnfPkgInfoSerializer(),
 207         status.HTTP_404_NOT_FOUND: openapi.Response("VNF package does not exist",
 208                                                     schema=openapi.Schema(type=openapi.TYPE_STRING)),
 209         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 210                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 211     }
 212 )
 213 @swagger_auto_schema(
 214     method='DELETE',
 215     operation_description="Delete an individual VNF package resource",
 216     tags=[TAG_VNF_PACKAGE_API],
 217     request_body=no_body,
 218     responses={
 219         status.HTTP_204_NO_CONTENT: "No content",
 220         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 221                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 222     }
 223 )
 224 @api_view(http_method_names=['GET', 'DELETE'])
 225 @view_safe_call_with_log(logger=logger)
 226 def vnf_package_rd(request, **kwargs):
 227     vnf_pkg_id = kwargs.get("vnfPkgId")
 228     if request.method == 'GET':
 229         # Read information about an individual VNF package
 230         logger.debug("Query an individual VNF package> %s" % request.data)
 231         data = VnfPackage().query_single(vnf_pkg_id)
 232         validate_data(data, VnfPkgInfoSerializer)
 233         return Response(data=data, status=status.HTTP_200_OK)
 234
 235     if request.method == 'DELETE':
 236         # Delete an individual VNF package
 237         logger.debug("Delete an individual VNF package> %s" % request.data)
 238         VnfPackage().delete_vnf_pkg(vnf_pkg_id)
 239         return Response(data=None, status=status.HTTP_204_NO_CONTENT)