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         logger.debug("Query VNF packages> %s" % request.data)
  68         data = VnfPackage().query_multiple()
  69         validate_data(data, VnfPkgInfosSerializer)
  70         return Response(data=data, status=status.HTTP_200_OK)
  71
  72     if request.method == 'POST':
  73         logger.debug("Create VNF package> %s" % request.data)
  74         create_vnf_pkg_info_request = validate_req_data(request.data, CreateVnfPkgInfoRequestSerializer)
  75         data = VnfPackage().create_vnf_pkg(create_vnf_pkg_info_request.data)
  76         validate_data(data, VnfPkgInfoSerializer)
  77         return Response(data=data, status=status.HTTP_201_CREATED)
  78
  79
  80 @swagger_auto_schema(
  81     auto_schema=EtsiCatalogFileAutoSchema,
  82     method="GET",
  83     operation_description="Read VNFD of an on-boarded VNF package",
  84     tags=[TAG_VNF_PACKAGE_API],
  85     request_body=no_body,
  86     responses={
  87         status.HTTP_200_OK: openapi.Response('VNFD of an on-boarded VNF package',
  88                                              schema=openapi.Schema(format=openapi.FORMAT_BINARY,
  89                                                                    type=openapi.TYPE_STRING)),
  90         status.HTTP_404_NOT_FOUND: openapi.Response("VNF package does not exist",
  91                                                     schema=openapi.Schema(type=openapi.TYPE_STRING)),
  92         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
  93                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
  94     },
  95     operation_id='VNFD of an on-boarded VNF package'
  96 )
  97 @api_view(http_method_names=["GET"])
  98 @view_safe_call_with_log(logger=logger)
  99 def vnfd_rd(request, **kwargs):
 100     vnf_pkg_id = kwargs.get("vnfPkgId")
 101     logger.debug("Read VNFD for  VNF package %s" % vnf_pkg_id)
 102     try:
 103         file_iterator = VnfPackage().download_vnfd(vnf_pkg_id)
 104         return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)
 105     except Exception as e:
 106         logger.error(e)
 107         raise e
 108
 109
 110 @swagger_auto_schema(
 111     method='PUT',
 112     operation_description="Upload VNF package content",
 113     tags=[TAG_VNF_PACKAGE_API],
 114     request_body=no_body,
 115     responses={
 116         status.HTTP_202_ACCEPTED: "Successfully",
 117         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 118                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 119     }
 120 )
 121 @swagger_auto_schema(
 122     auto_schema=EtsiCatalogFileAutoSchema,
 123     method="GET",
 124     operation_description="Fetch VNF package content",
 125     tags=[TAG_VNF_PACKAGE_API],
 126     request_body=no_body,
 127     responses={
 128         status.HTTP_200_OK: openapi.Response('VNF package file',
 129                                              schema=openapi.Schema(format=openapi.FORMAT_BINARY,
 130                                                                    type=openapi.TYPE_STRING)),
 131         status.HTTP_404_NOT_FOUND: openapi.Response("VNF package does not exist",
 132                                                     schema=openapi.Schema(type=openapi.TYPE_STRING)),
 133         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 134                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 135     }
 136 )
 137 @api_view(http_method_names=["PUT", "GET"])
 138 @view_safe_call_with_log(logger=logger)
 139 def package_content_ru(request, **kwargs):
 140     vnf_pkg_id = kwargs.get("vnfPkgId")
 141     if request.method == "PUT":
 142         logger.debug("Upload VNF package %s" % vnf_pkg_id)
 143         files = request.FILES.getlist('file')
 144         try:
 145             local_file_name = VnfPackage().upload(vnf_pkg_id, files[0])
 146             parse_vnfd_and_save(vnf_pkg_id, local_file_name)
 147             return Response(None, status=status.HTTP_202_ACCEPTED)
 148         except Exception as e:
 149             handle_upload_failed(vnf_pkg_id)
 150             raise e
 151
 152     if request.method == "GET":
 153         file_range = request.META.get('HTTP_RANGE')
 154         file_iterator = VnfPackage().download(vnf_pkg_id, file_range)
 155         return StreamingHttpResponse(file_iterator, status=status.HTTP_200_OK)
 156
 157
 158 @swagger_auto_schema(
 159     method='POST',
 160     operation_description="Upload VNF package content from uri",
 161     tags=[TAG_VNF_PACKAGE_API],
 162     request_body=UploadVnfPackageFromUriRequestSerializer,
 163     responses={
 164         status.HTTP_202_ACCEPTED: "Successfully",
 165         status.HTTP_400_BAD_REQUEST: openapi.Response("Bad Request", schema=openapi.Schema(type=openapi.TYPE_STRING)),
 166         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 167                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 168     }
 169 )
 170 @api_view(http_method_names=['POST'])
 171 @view_safe_call_with_log(logger=logger)
 172 def upload_from_uri_c(request, **kwargs):
 173     vnf_pkg_id = kwargs.get("vnfPkgId")
 174     try:
 175         upload_vnf_from_uri_request = validate_req_data(request.data,
 176                                                         UploadVnfPackageFromUriRequestSerializer)
 177         VnfPkgUploadThread(upload_vnf_from_uri_request.data, vnf_pkg_id).start()
 178         return Response(None, status=status.HTTP_202_ACCEPTED)
 179     except Exception as e:
 180         handle_upload_failed(vnf_pkg_id)
 181         raise e
 182
 183
 184 @swagger_auto_schema(
 185     method='GET',
 186     operation_description="Query an individual VNF package resource",
 187     tags=[TAG_VNF_PACKAGE_API],
 188     request_body=no_body,
 189     responses={
 190         status.HTTP_200_OK: VnfPkgInfoSerializer(),
 191         status.HTTP_404_NOT_FOUND: openapi.Response("VNF package does not exist",
 192                                                     schema=openapi.Schema(type=openapi.TYPE_STRING)),
 193         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 194                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 195     }
 196 )
 197 @swagger_auto_schema(
 198     method='DELETE',
 199     operation_description="Delete an individual VNF package resource",
 200     tags=[TAG_VNF_PACKAGE_API],
 201     request_body=no_body,
 202     responses={
 203         status.HTTP_204_NO_CONTENT: "No content",
 204         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response("Internal error",
 205                                                                 schema=openapi.Schema(type=openapi.TYPE_STRING))
 206     }
 207 )
 208 @api_view(http_method_names=['GET', 'DELETE'])
 209 @view_safe_call_with_log(logger=logger)
 210 def vnf_package_rd(request, **kwargs):
 211     vnf_pkg_id = kwargs.get("vnfPkgId")
 212     if request.method == 'GET':
 213         logger.debug("Query an individual VNF package> %s" % request.data)
 214         data = VnfPackage().query_single(vnf_pkg_id)
 215         validate_data(data, VnfPkgInfoSerializer)
 216         return Response(data=data, status=status.HTTP_200_OK)
 217
 218     if request.method == 'DELETE':
 219         logger.debug("Delete an individual VNF package> %s" % request.data)
 220         VnfPackage().delete_vnf_pkg(vnf_pkg_id)
 221         return Response(data=None, status=status.HTTP_204_NO_CONTENT)