catalog/packages/views/catalog_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 uuid
  17
  18 from drf_yasg import openapi
  19 from drf_yasg.utils import no_body, swagger_auto_schema
  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 import nf_package, ns_package
  25 from catalog.packages.serializers.catalog_serializers import InternalErrorRequestSerializer
  26 from catalog.packages.serializers.catalog_serializers import NfPackageDistributeRequestSerializer
  27 from catalog.packages.serializers.catalog_serializers import NfPackageSerializer
  28 from catalog.packages.serializers.catalog_serializers import NfPackagesSerializer
  29 from catalog.packages.serializers.catalog_serializers import NsPackageDistributeRequestSerializer
  30 from catalog.packages.serializers.catalog_serializers import NsPackageDistributeResponseSerializer
  31 from catalog.packages.serializers.catalog_serializers import NsPackageSerializer
  32 from catalog.packages.serializers.catalog_serializers import NsPackagesSerializer
  33 from catalog.packages.serializers.catalog_serializers import ParseModelRequestSerializer
  34 from catalog.packages.serializers.catalog_serializers import ParseModelResponseSerializer
  35 from catalog.packages.serializers.catalog_serializers import PostJobResponseSerializer
  36 from catalog.pub.utils.syscomm import fun_name
  37 from catalog.pub.utils.values import ignore_case_get
  38
  39 logger = logging.getLogger(__name__)
  40
  41
  42 @swagger_auto_schema(
  43     method='POST',
  44     operation_description="On distribute NS package",
  45     request_body=NsPackageDistributeRequestSerializer,
  46     responses={
  47         status.HTTP_202_ACCEPTED: NsPackageDistributeResponseSerializer,
  48         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
  49 @swagger_auto_schema(
  50     method='GET',
  51     operation_description="Query NS packages",
  52     request_body=no_body,
  53     responses={
  54         status.HTTP_200_OK: NsPackagesSerializer,
  55         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
  56 @api_view(http_method_names=['POST', 'GET'])
  57 def nspackages_rc(request, *args, **kwargs):
  58     logger.debug("Enter %s, method is %s", fun_name(), request.method)
  59     ret, normal_status, response_serializer, validation_error = None, None, None, None
  60
  61     if request.method == 'GET':
  62         # Gets ns package list
  63         ret = ns_package.ns_get_csars()
  64         normal_status = status.HTTP_200_OK
  65
  66         if ret[0] == 0:
  67             response_serializer = NsPackagesSerializer(data=ret[1])
  68             validation_error = handleValidatonError(
  69                 response_serializer, False)
  70             if validation_error:
  71                 return validation_error
  72     elif request.method == 'POST':
  73         # Distributes the package accroding to the given csarId
  74         request_serializer = NsPackageDistributeRequestSerializer(data=request.data)
  75         validation_error = handleValidatonError(request_serializer, True)
  76         if validation_error:
  77             return validation_error
  78
  79         csar_id = ignore_case_get(request.data, "csarId")
  80         logger.debug("csar_id is %s", csar_id)
  81         ret = ns_package.ns_on_distribute(csar_id)
  82         normal_status = status.HTTP_202_ACCEPTED
  83
  84     logger.debug("Leave %s, Return value is %s", fun_name(), ret)
  85     if ret[0] != 0:
  86         return Response(
  87             data={
  88                 'error': ret[1]},
  89             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  90
  91     return Response(data=ret[1], status=normal_status)
  92
  93
  94 @swagger_auto_schema(
  95     method='POST',
  96     operation_description="On distribute Nf package",
  97     request_body=NfPackageDistributeRequestSerializer(),
  98     responses={
  99         status.HTTP_202_ACCEPTED: PostJobResponseSerializer,
 100         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 101 @swagger_auto_schema(
 102     method='GET',
 103     operation_description="Query Nf packages",
 104     request_body=no_body,
 105     responses={
 106         status.HTTP_200_OK: NfPackagesSerializer,
 107         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 108 @api_view(http_method_names=['POST', 'GET'])
 109 def nfpackages_rc(request, *args, **kwargs):
 110     logger.debug(
 111         "Enter %s%s, method is %s",
 112         fun_name(),
 113         request.data,
 114         request.method)
 115     ret, normal_status, response_serializer, validation_error = None, None, None, None
 116     if request.method == 'GET':
 117         ret = nf_package.nf_get_csars()
 118         normal_status = status.HTTP_200_OK
 119         response_serializer = NfPackagesSerializer(data=ret[1])
 120     elif request.method == 'POST':
 121         request_serivalizer = NfPackageDistributeRequestSerializer(
 122             data=request.data)
 123         validation_error = handleValidatonError(
 124             request_serivalizer, True)
 125         if validation_error:
 126             return validation_error
 127
 128         csar_id = ignore_case_get(request_serivalizer.data, "csarId")
 129         vim_ids = ignore_case_get(request_serivalizer.data, "vimIds")
 130         lab_vim_id = ignore_case_get(request_serivalizer.data, "labVimId")
 131         job_id = str(uuid.uuid4())
 132         nf_package.NfDistributeThread(
 133             csar_id, vim_ids, lab_vim_id, job_id).start()
 134         ret = [0, {"jobId": job_id}]
 135         normal_status = status.HTTP_202_ACCEPTED
 136
 137         response_serializer = PostJobResponseSerializer(data=ret[1])
 138     logger.debug("Leave %s, Return value is %s", fun_name(), ret)
 139
 140     if ret[0] != 0:
 141         return Response(
 142             data={
 143                 'error': ret[1]},
 144             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 145
 146     validation_error = handleValidatonError(
 147         response_serializer, False)
 148     if validation_error:
 149         return validation_error
 150
 151     return Response(data=response_serializer.data, status=normal_status)
 152
 153
 154 @swagger_auto_schema(
 155     method='DELETE',
 156     operation_description="Delete one NS package",
 157     request_body=no_body,
 158     manual_parameters=[
 159         openapi.Parameter(
 160             'csarId',
 161             openapi.IN_QUERY,
 162             "csarId",
 163             type=openapi.TYPE_STRING)],
 164     responses={
 165         status.HTTP_200_OK: NsPackageDistributeResponseSerializer,
 166         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 167             'error message',
 168             openapi.Schema(
 169                 type=openapi.TYPE_STRING))})
 170 @swagger_auto_schema(
 171     method='GET',
 172     operation_description="Query one NS package",
 173     request_body=no_body,
 174     manual_parameters=[
 175         openapi.Parameter(
 176             'csarId',
 177             openapi.IN_QUERY,
 178             "csarId",
 179             type=openapi.TYPE_STRING)],
 180     responses={
 181         status.HTTP_200_OK: NsPackageSerializer,
 182         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 183             'error message',
 184             openapi.Schema(
 185                 type=openapi.TYPE_STRING))})
 186 @api_view(http_method_names=['DELETE', 'GET'])
 187 def ns_rd_csar(request, *args, **kwargs):
 188     csar_id = ignore_case_get(kwargs, "csarId")
 189     logger.info("Enter %s, method is %s, csar_id is %s",
 190                 fun_name(), request.method, csar_id)
 191     ret, normal_status, response_serializer, validation_error = None, None, None, None
 192     if request.method == 'GET':
 193         ret = ns_package.ns_get_csar(csar_id)
 194         normal_status = status.HTTP_200_OK
 195         if ret[0] == 0:
 196             response_serializer = NsPackageSerializer(data=ret[1])
 197             validation_error = handleValidatonError(response_serializer, False)
 198             if validation_error:
 199                 return validation_error
 200     elif request.method == 'DELETE':
 201         ret = ns_package.ns_delete_csar(csar_id)
 202         normal_status = status.HTTP_200_OK
 203     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 204     if ret[0] != 0:
 205         return Response(
 206             data={
 207                 'error': ret[1]},
 208             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 209     return Response(data=ret[1], status=normal_status)
 210
 211
 212 @swagger_auto_schema(
 213     method='DELETE',
 214     operation_description="Delete one Nf package",
 215     request_body=no_body,
 216     manual_parameters=[
 217         openapi.Parameter(
 218             'csarId',
 219             openapi.IN_QUERY,
 220             "csarId",
 221             type=openapi.TYPE_STRING)],
 222     responses={
 223         status.HTTP_202_ACCEPTED: PostJobResponseSerializer,
 224         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 225             'error message',
 226             openapi.Schema(
 227                 type=openapi.TYPE_STRING))})
 228 @swagger_auto_schema(
 229     method='GET',
 230     operation_description="Query one Nf package",
 231     request_body=no_body,
 232     manual_parameters=[
 233         openapi.Parameter(
 234             'csarId',
 235             openapi.IN_QUERY,
 236             "csarId",
 237             type=openapi.TYPE_STRING)],
 238     responses={
 239         status.HTTP_200_OK: NfPackageSerializer,
 240         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 241             'error message',
 242             openapi.Schema(
 243                 type=openapi.TYPE_STRING))})
 244 @api_view(http_method_names=['DELETE', 'GET'])
 245 def nf_rd_csar(request, *args, **kwargs):
 246     csar_id = ignore_case_get(kwargs, "csarId")
 247     logger.info("Enter %s, method is %s, csar_id is %s",
 248                 fun_name(), request.method, csar_id)
 249     ret, normal_status, response_serializer, validation_error = None, None, None, None
 250
 251     if request.method == 'GET':
 252         ret = nf_package.nf_get_csar(csar_id)
 253         normal_status = status.HTTP_200_OK
 254         response_serializer = NfPackageSerializer(data=ret[1])
 255
 256     elif request.method == 'DELETE':
 257         job_id = str(uuid.uuid4())
 258         nf_package.NfPkgDeleteThread(csar_id, job_id).start()
 259         ret = [0, {"jobId": job_id}]
 260         normal_status = status.HTTP_202_ACCEPTED
 261         response_serializer = PostJobResponseSerializer(data=ret[1])
 262
 263     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 264     if ret[0] != 0:
 265         return Response(
 266             data={
 267                 'error': ret[1]},
 268             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 269
 270     validation_error = handleValidatonError(
 271         response_serializer, False)
 272     if validation_error:
 273         return validation_error
 274
 275     return Response(data=response_serializer.data, status=normal_status)
 276
 277
 278 @swagger_auto_schema(
 279     method='POST',
 280     operation_description="Parse NS model",
 281     request_body=ParseModelRequestSerializer,
 282     responses={
 283         status.HTTP_202_ACCEPTED: ParseModelResponseSerializer,
 284         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 285 @api_view(http_method_names=['POST'])
 286 def ns_model_parser(request, *args, **kwargs):
 287     csar_id = ignore_case_get(request.data, "csarId")
 288     inputs = ignore_case_get(request.data, "inputs")
 289     logger.debug(
 290         "Enter %s, csar_id=%s, inputs=%s",
 291         fun_name(),
 292         csar_id,
 293         inputs)
 294     ret = ns_package.parse_nsd(csar_id, inputs)
 295     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 296     if ret[0] != 0:
 297         return Response(
 298             data={
 299                 'error': ret[1]},
 300             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 301
 302     response_serializer = ParseModelResponseSerializer(data=ret[1])
 303     validation_error = handleValidatonError(
 304         response_serializer, False)
 305     if validation_error:
 306         return validation_error
 307
 308     return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 309
 310
 311 @swagger_auto_schema(
 312     method='POST',
 313     operation_description="Parse NF model",
 314     request_body=ParseModelRequestSerializer,
 315     responses={
 316         status.HTTP_202_ACCEPTED: ParseModelResponseSerializer,
 317         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 318 @api_view(http_method_names=['POST'])
 319 def vnf_model_parser(request, *args, **kwargs):
 320     csar_id = ignore_case_get(request.data, "csarId")
 321     inputs = ignore_case_get(request.data, "inputs")
 322     logger.debug(
 323         "Enter %s, csar_id=%s, inputs=%s",
 324         fun_name(),
 325         csar_id,
 326         inputs)
 327     ret = nf_package.parse_vnfd(csar_id, inputs)
 328     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 329     if ret[0] != 0:
 330         return Response(
 331             data={
 332                 'error': ret[1]},
 333             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 334
 335     response_serializer = ParseModelResponseSerializer(data=ret[1])
 336     validation_error = handleValidatonError(
 337         response_serializer, False)
 338     if validation_error:
 339         return validation_error
 340
 341     return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 342
 343
 344 def handleValidatonError(base_serializer, is_request):
 345     response = None
 346
 347     if not base_serializer.is_valid():
 348         errormessage = base_serializer.errors
 349         logger.error(errormessage)
 350
 351         if is_request:
 352             message = 'Invalid request'
 353         else:
 354             message = 'Invalid response'
 355         logger.error(message)
 356         response = Response(
 357             data={'error': errormessage},
 358             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 359
 360     return response