catalog/packages/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 from catalog.pub.utils.syscomm import fun_name
  18 from rest_framework.response import Response
  19 from rest_framework import status
  20 from rest_framework.decorators import api_view
  21 from catalog.pub.utils.values import ignore_case_get
  22 from catalog.packages import nf_package
  23 from catalog.packages import ns_package
  24 from catalog.serializers import NsPackagesSerializer
  25 from catalog.serializers import NsPackageSerializer
  26 from catalog.serializers import NfPackagesSerializer
  27 from catalog.serializers import NsPackageDistributeRequestSerializer
  28 from catalog.serializers import NsPackageDistributeResponseSerializer
  29 from catalog.serializers import NfPackageDistributeRequestSerializer
  30 from catalog.serializers import NfPackageSerializer
  31 from catalog.serializers import ParseModelRequestSerializer
  32 from catalog.serializers import ParseModelResponseSerializer
  33 from catalog.serializers import InternalErrorRequestSerializer
  34 from catalog.serializers import PostJobResponseSerializer
  35 from drf_yasg import openapi
  36 from drf_yasg.utils import no_body, swagger_auto_schema
  37
  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: openapi.Response(
 166             'Delete CSAR successfully',
 167             openapi.Schema(
 168                 type=openapi.TYPE_STRING)),
 169         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 170             'error message',
 171             openapi.Schema(
 172                 type=openapi.TYPE_STRING))})
 173 @swagger_auto_schema(
 174     method='GET',
 175     operation_description="Query one NS package",
 176     request_body=no_body,
 177     manual_parameters=[
 178         openapi.Parameter(
 179             'csarId',
 180             openapi.IN_QUERY,
 181             "csarId",
 182             type=openapi.TYPE_STRING)],
 183     responses={
 184         status.HTTP_200_OK: NsPackageSerializer,
 185         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 186             'error message',
 187             openapi.Schema(
 188                 type=openapi.TYPE_STRING))})
 189 @api_view(http_method_names=['DELETE', 'GET'])
 190 def ns_rd_csar(request, *args, **kwargs):
 191     csar_id = ignore_case_get(kwargs, "csarId")
 192     logger.info("Enter %s, method is %s, csar_id is %s",
 193                 fun_name(), request.method, csar_id)
 194     ret, normal_status, response_serializer, validation_error = None, None, None, None
 195     if request.method == 'GET':
 196         ret = ns_package.ns_get_csar(csar_id)
 197         normal_status = status.HTTP_200_OK
 198         if ret[0] == 0:
 199             response_serializer = NsPackageSerializer(data=ret[1])
 200             validation_error = handleValidatonError(response_serializer, False)
 201             if validation_error:
 202                 return validation_error
 203     elif request.method == 'DELETE':
 204         ret = ns_package.ns_delete_csar(csar_id)
 205         normal_status = status.HTTP_202_ACCEPTED
 206     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 207     if ret[0] != 0:
 208         return Response(
 209             data={
 210                 'error': ret[1]},
 211             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 212     return Response(data=ret[1], status=normal_status)
 213
 214
 215 @swagger_auto_schema(
 216     method='DELETE',
 217     operation_description="Delete one Nf package",
 218     request_body=no_body,
 219     manual_parameters=[
 220         openapi.Parameter(
 221             'csarId',
 222             openapi.IN_QUERY,
 223             "csarId",
 224             type=openapi.TYPE_STRING)],
 225     responses={
 226         status.HTTP_200_OK: PostJobResponseSerializer,
 227         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 228             'error message',
 229             openapi.Schema(
 230                 type=openapi.TYPE_STRING))})
 231 @swagger_auto_schema(
 232     method='GET',
 233     operation_description="Query one Nf package",
 234     request_body=no_body,
 235     manual_parameters=[
 236         openapi.Parameter(
 237             'csarId',
 238             openapi.IN_QUERY,
 239             "csarId",
 240             type=openapi.TYPE_STRING)],
 241     responses={
 242         status.HTTP_200_OK: NfPackageSerializer,
 243         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 244             'error message',
 245             openapi.Schema(
 246                 type=openapi.TYPE_STRING))})
 247 @api_view(http_method_names=['DELETE', 'GET'])
 248 def nf_rd_csar(request, *args, **kwargs):
 249     csar_id = ignore_case_get(kwargs, "csarId")
 250     logger.info("Enter %s, method is %s, csar_id is %s",
 251                 fun_name(), request.method, csar_id)
 252     ret, normal_status, response_serializer, validation_error = None, None, None, None
 253
 254     if request.method == 'GET':
 255         ret = nf_package.nf_get_csar(csar_id)
 256         normal_status = status.HTTP_200_OK
 257         response_serializer = NfPackageSerializer(data=ret[1])
 258
 259     elif request.method == 'DELETE':
 260         job_id = str(uuid.uuid4())
 261         nf_package.NfPkgDeleteThread(csar_id, job_id).start()
 262         ret = [0, {"jobId": job_id}]
 263         normal_status = status.HTTP_202_ACCEPTED
 264         response_serializer = PostJobResponseSerializer(data=ret[1])
 265
 266     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 267     if ret[0] != 0:
 268         return Response(
 269             data={
 270                 'error': ret[1]},
 271             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 272
 273     validation_error = handleValidatonError(
 274         response_serializer, False)
 275     if validation_error:
 276         return validation_error
 277
 278     return Response(data=response_serializer.data, status=normal_status)
 279
 280
 281 @swagger_auto_schema(
 282     method='POST',
 283     operation_description="Parse NS model",
 284     request_body=ParseModelRequestSerializer,
 285     responses={
 286         status.HTTP_202_ACCEPTED: ParseModelResponseSerializer,
 287         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 288 @api_view(http_method_names=['POST'])
 289 def ns_model_parser(request, *args, **kwargs):
 290     csar_id = ignore_case_get(request.data, "csarId")
 291     inputs = ignore_case_get(request.data, "inputs")
 292     logger.debug(
 293         "Enter %s, csar_id=%s, inputs=%s",
 294         fun_name(),
 295         csar_id,
 296         inputs)
 297     ret = ns_package.parse_nsd(csar_id, inputs)
 298     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 299     if ret[0] != 0:
 300         return Response(
 301             data={
 302                 'error': ret[1]},
 303             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 304
 305     response_serializer = ParseModelResponseSerializer(data=ret[1])
 306     validation_error = handleValidatonError(
 307         response_serializer, False)
 308     if validation_error:
 309         return validation_error
 310
 311     return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 312
 313
 314 @swagger_auto_schema(
 315     method='POST',
 316     operation_description="Parse NF model",
 317     request_body=ParseModelRequestSerializer,
 318     responses={
 319         status.HTTP_202_ACCEPTED: ParseModelResponseSerializer,
 320         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 321 @api_view(http_method_names=['POST'])
 322 def vnf_model_parser(request, *args, **kwargs):
 323     csar_id = ignore_case_get(request.data, "csarId")
 324     inputs = ignore_case_get(request.data, "inputs")
 325     logger.debug(
 326         "Enter %s, csar_id=%s, inputs=%s",
 327         fun_name(),
 328         csar_id,
 329         inputs)
 330     ret = nf_package.parse_vnfd(csar_id, inputs)
 331     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 332     if ret[0] != 0:
 333         return Response(
 334             data={
 335                 'error': ret[1]},
 336             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 337
 338     response_serializer = ParseModelResponseSerializer(data=ret[1])
 339     validation_error = handleValidatonError(
 340         response_serializer, False)
 341     if validation_error:
 342         return validation_error
 343
 344     return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 345
 346
 347 def handleValidatonError(base_serializer, is_request):
 348     response = None
 349
 350     if not base_serializer.is_valid():
 351         errormessage = base_serializer.errors
 352         logger.error(errormessage)
 353
 354         if is_request:
 355             message = 'Invalid request'
 356         else:
 357             message = 'Invalid response'
 358         logger.error(message)
 359         response = Response(
 360             data={'error': errormessage},
 361             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 362
 363     return response