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 from catalog.packages.biz import sdc_vnf_package, sdc_ns_package
  24 from catalog.packages.biz.pnf_descriptor import PnfDescriptor
  25 from catalog.packages.biz.sdc_service_package import ServicePackage
  26 from catalog.packages.serializers.catalog_serializers import InternalErrorRequestSerializer, \
  27     ServicePackageDistributeRequestSerializer, ServicePackagesSerializer, ServicePackageSerializer
  28 from catalog.packages.serializers.catalog_serializers import NfPackageDistributeRequestSerializer
  29 from catalog.packages.serializers.catalog_serializers import NfPackageSerializer
  30 from catalog.packages.serializers.catalog_serializers import NfPackagesSerializer
  31 from catalog.packages.serializers.catalog_serializers import NsPackageDistributeRequestSerializer
  32 from catalog.packages.serializers.catalog_serializers import NsPackageDistributeResponseSerializer
  33 from catalog.packages.serializers.catalog_serializers import NsPackageSerializer
  34 from catalog.packages.serializers.catalog_serializers import NsPackagesSerializer
  35 from catalog.packages.serializers.catalog_serializers import ParseModelRequestSerializer
  36 from catalog.packages.serializers.catalog_serializers import ParseModelResponseSerializer
  37 from catalog.packages.serializers.catalog_serializers import PostJobResponseSerializer
  38 from catalog.packages.views.common import fmt_error_rsp
  39 from catalog.pub.exceptions import PackageNotFoundException, PackageHasExistsException
  40 from catalog.pub.utils.syscomm import fun_name
  41 from catalog.pub.utils.values import ignore_case_get
  42
  43 logger = logging.getLogger(__name__)
  44
  45
  46 @swagger_auto_schema(
  47     method='POST',
  48     operation_description="On distribute NS package",
  49     tags=["NS packages API"],
  50     request_body=NsPackageDistributeRequestSerializer,
  51     responses={
  52         status.HTTP_202_ACCEPTED: NsPackageDistributeResponseSerializer,
  53         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
  54 @swagger_auto_schema(
  55     method='GET',
  56     operation_description="Query NS packages",
  57     tags=["NS packages API"],
  58     request_body=no_body,
  59     responses={
  60         status.HTTP_200_OK: NsPackagesSerializer,
  61         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
  62 @api_view(http_method_names=['POST', 'GET'])
  63 def nspackages_rc(request, *args, **kwargs):
  64     logger.debug("Enter %s, method is %s", fun_name(), request.method)
  65     ret, normal_status, response_serializer, validation_error = None, None, None, None
  66
  67     if request.method == 'GET':
  68         # Gets ns package list
  69         ret = sdc_ns_package.ns_get_csars()
  70         normal_status = status.HTTP_200_OK
  71
  72         if ret[0] == 0:
  73             response_serializer = NsPackagesSerializer(data=ret[1])
  74             validation_error = handleValidatonError(
  75                 response_serializer, False)
  76             if validation_error:
  77                 return validation_error
  78     elif request.method == 'POST':
  79         # Distributes the package accroding to the given csarId
  80         request_serializer = NsPackageDistributeRequestSerializer(data=request.data)
  81         validation_error = handleValidatonError(request_serializer, True)
  82         if validation_error:
  83             return validation_error
  84
  85         csar_id = ignore_case_get(request.data, "csarId")
  86         logger.debug("csar_id is %s", csar_id)
  87         ret = sdc_ns_package.ns_on_distribute(csar_id)
  88         normal_status = status.HTTP_202_ACCEPTED
  89
  90     logger.debug("Leave %s, Return value is %s", fun_name(), ret)
  91     if ret[0] != 0:
  92         return Response(
  93             data={
  94                 'error': ret[1]},
  95             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
  96
  97     return Response(data=ret[1], status=normal_status)
  98
  99
 100 @swagger_auto_schema(
 101     method='POST',
 102     operation_description="On distribute Nf package",
 103     tags=["NF packages API"],
 104     request_body=NfPackageDistributeRequestSerializer(),
 105     responses={
 106         status.HTTP_202_ACCEPTED: PostJobResponseSerializer,
 107         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 108 @swagger_auto_schema(
 109     method='GET',
 110     operation_description="Query Nf packages",
 111     tags=["NF packages API"],
 112     request_body=no_body,
 113     responses={
 114         status.HTTP_200_OK: NfPackagesSerializer,
 115         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 116 @api_view(http_method_names=['POST', 'GET'])
 117 def nfpackages_rc(request, *args, **kwargs):
 118     logger.debug(
 119         "Enter %s%s, method is %s",
 120         fun_name(),
 121         request.data,
 122         request.method)
 123     ret, normal_status, response_serializer, validation_error = None, None, None, None
 124     if request.method == 'GET':
 125         ret = sdc_vnf_package.nf_get_csars()
 126         normal_status = status.HTTP_200_OK
 127         response_serializer = NfPackagesSerializer(data=ret[1])
 128     elif request.method == 'POST':
 129         request_serivalizer = NfPackageDistributeRequestSerializer(
 130             data=request.data)
 131         validation_error = handleValidatonError(
 132             request_serivalizer, True)
 133         if validation_error:
 134             return validation_error
 135
 136         csar_id = ignore_case_get(request_serivalizer.data, "csarId")
 137         vim_ids = ignore_case_get(request_serivalizer.data, "vimIds")
 138         lab_vim_id = ignore_case_get(request_serivalizer.data, "labVimId")
 139         job_id = str(uuid.uuid4())
 140         sdc_vnf_package.NfDistributeThread(
 141             csar_id, vim_ids, lab_vim_id, job_id).start()
 142         ret = [0, {"jobId": job_id}]
 143         normal_status = status.HTTP_202_ACCEPTED
 144
 145         response_serializer = PostJobResponseSerializer(data=ret[1])
 146     logger.debug("Leave %s, Return value is %s", fun_name(), ret)
 147
 148     if ret[0] != 0:
 149         return Response(
 150             data={
 151                 'error': ret[1]},
 152             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 153
 154     validation_error = handleValidatonError(
 155         response_serializer, False)
 156     if validation_error:
 157         return validation_error
 158
 159     return Response(data=response_serializer.data, status=normal_status)
 160
 161
 162 @swagger_auto_schema(
 163     method='DELETE',
 164     operation_description="Delete one NS package",
 165     tags=["NS packages API"],
 166     request_body=no_body,
 167     manual_parameters=[
 168         openapi.Parameter(
 169             'csarId',
 170             openapi.IN_QUERY,
 171             "csarId",
 172             type=openapi.TYPE_STRING)],
 173     responses={
 174         status.HTTP_200_OK: NsPackageDistributeResponseSerializer,
 175         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 176             'error message',
 177             openapi.Schema(
 178                 type=openapi.TYPE_STRING))})
 179 @swagger_auto_schema(
 180     method='GET',
 181     operation_description="Query one NS package",
 182     tags=["NS packages API"],
 183     request_body=no_body,
 184     manual_parameters=[
 185         openapi.Parameter(
 186             'csarId',
 187             openapi.IN_QUERY,
 188             "csarId",
 189             type=openapi.TYPE_STRING)],
 190     responses={
 191         status.HTTP_200_OK: NsPackageSerializer,
 192         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 193             'error message',
 194             openapi.Schema(
 195                 type=openapi.TYPE_STRING))})
 196 @api_view(http_method_names=['DELETE', 'GET'])
 197 def ns_rd_csar(request, *args, **kwargs):
 198     csar_id = ignore_case_get(kwargs, "csarId")
 199     logger.info("Enter %s, method is %s, csar_id is %s",
 200                 fun_name(), request.method, csar_id)
 201     ret, normal_status, response_serializer, validation_error = None, None, None, None
 202     if request.method == 'GET':
 203         ret = sdc_ns_package.ns_get_csar(csar_id)
 204         normal_status = status.HTTP_200_OK
 205         if ret[0] == 0:
 206             response_serializer = NsPackageSerializer(data=ret[1])
 207             validation_error = handleValidatonError(response_serializer, False)
 208             if validation_error:
 209                 return validation_error
 210     elif request.method == 'DELETE':
 211         ret = sdc_ns_package.ns_delete_csar(csar_id)
 212         normal_status = status.HTTP_200_OK
 213     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 214     if ret[0] != 0:
 215         return Response(
 216             data={
 217                 'error': ret[1]},
 218             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 219     return Response(data=ret[1], status=normal_status)
 220
 221
 222 @swagger_auto_schema(
 223     method='POST',
 224     operation_description="On distribute Service package",
 225     tags=["Service packages API"],
 226     request_body=ServicePackageDistributeRequestSerializer,
 227     responses={
 228         status.HTTP_202_ACCEPTED: "",
 229         status.HTTP_400_BAD_REQUEST: InternalErrorRequestSerializer,
 230         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 231 @swagger_auto_schema(
 232     method='GET',
 233     operation_description="Query Service packages",
 234     tags=["Service packages API"],
 235     request_body=no_body,
 236     responses={
 237         status.HTTP_200_OK: ServicePackagesSerializer,
 238         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 239 @api_view(http_method_names=['POST', 'GET'])
 240 def servicepackages_rc(request, *args, **kwargs):
 241     logger.debug("Enter %s, method is %s", fun_name(), request.method)
 242
 243     if request.method == 'GET':
 244         # Gets service package list
 245         try:
 246             csar_list = ServicePackage().get_csars()
 247             response_serializer = ServicePackagesSerializer(data=csar_list)
 248             validation_error = handleValidatonError(response_serializer, False)
 249             if validation_error:
 250                 return validation_error
 251             return Response(data=csar_list, status=status.HTTP_200_OK)
 252         except Exception as e:
 253             error_status = status.HTTP_500_INTERNAL_SERVER_ERROR
 254             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 255     elif request.method == 'POST':
 256         # Distributes the package according to the given csarId
 257         request_serializer = ServicePackageDistributeRequestSerializer(data=request.data)
 258         validation_error = handleValidatonError(request_serializer, True)
 259         if validation_error:
 260             return validation_error
 261
 262         csar_id = ignore_case_get(request.data, "csarId")
 263         logger.debug("csar_id is %s", csar_id)
 264         try:
 265             ServicePackage().on_distribute(csar_id)
 266             return Response(status=status.HTTP_202_ACCEPTED)
 267         except PackageHasExistsException as e:
 268             error_status = status.HTTP_400_BAD_REQUEST
 269             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 270         except Exception as e:
 271             error_status = status.HTTP_500_INTERNAL_SERVER_ERROR
 272             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 273
 274
 275 @swagger_auto_schema(
 276     method='DELETE',
 277     operation_description="Delete one Service package",
 278     tags=["Service packages API"],
 279     request_body=no_body,
 280     manual_parameters=[
 281         openapi.Parameter(
 282             'csarId',
 283             openapi.IN_QUERY,
 284             "csarId",
 285             type=openapi.TYPE_STRING)],
 286     responses={
 287         status.HTTP_204_NO_CONTENT: "",
 288         status.HTTP_404_NOT_FOUND: InternalErrorRequestSerializer,
 289         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 290 @swagger_auto_schema(
 291     method='GET',
 292     operation_description="Query one Service package",
 293     tags=["Service packages API"],
 294     request_body=no_body,
 295     manual_parameters=[
 296         openapi.Parameter(
 297             'csarId',
 298             openapi.IN_QUERY,
 299             "csarId",
 300             type=openapi.TYPE_STRING)],
 301     responses={
 302         status.HTTP_200_OK: ServicePackageSerializer,
 303         status.HTTP_404_NOT_FOUND: InternalErrorRequestSerializer,
 304         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 305 @api_view(http_method_names=['DELETE', 'GET'])
 306 def service_rd_csar(request, *args, **kwargs):
 307     csar_id = ignore_case_get(kwargs, "csarId")
 308     logger.info("Enter %s, method is %s, csar_id is %s", fun_name(), request.method, csar_id)
 309
 310     if request.method == 'GET':
 311         try:
 312             ret = ServicePackage().get_csar(csar_id)
 313             response_serializer = ServicePackageSerializer(data=ret)
 314             validation_error = handleValidatonError(response_serializer, False)
 315             if validation_error:
 316                 return validation_error
 317             return Response(data=ret, status=status.HTTP_200_OK)
 318         except PackageNotFoundException as e:
 319             error_status = status.HTTP_404_NOT_FOUND
 320             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 321         except Exception as e:
 322             error_status = status.HTTP_500_INTERNAL_SERVER_ERROR
 323             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 324
 325     elif request.method == 'DELETE':
 326         try:
 327             ServicePackage().delete_csar(csar_id)
 328             return Response(status=status.HTTP_204_NO_CONTENT)
 329         except PackageNotFoundException as e:
 330             error_status = status.HTTP_404_NOT_FOUND
 331             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 332         except Exception as e:
 333             error_status = status.HTTP_500_INTERNAL_SERVER_ERROR
 334             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 335
 336
 337 @swagger_auto_schema(
 338     method='DELETE',
 339     operation_description="Delete one Nf package",
 340     tags=["NF packages API"],
 341     request_body=no_body,
 342     manual_parameters=[
 343         openapi.Parameter(
 344             'csarId',
 345             openapi.IN_QUERY,
 346             "csarId",
 347             type=openapi.TYPE_STRING)],
 348     responses={
 349         status.HTTP_202_ACCEPTED: PostJobResponseSerializer,
 350         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 351             'error message',
 352             openapi.Schema(
 353                 type=openapi.TYPE_STRING))})
 354 @swagger_auto_schema(
 355     method='GET',
 356     operation_description="Query one Nf package",
 357     tags=["NF packages API"],
 358     request_body=no_body,
 359     manual_parameters=[
 360         openapi.Parameter(
 361             'csarId',
 362             openapi.IN_QUERY,
 363             "csarId",
 364             type=openapi.TYPE_STRING)],
 365     responses={
 366         status.HTTP_200_OK: NfPackageSerializer,
 367         status.HTTP_500_INTERNAL_SERVER_ERROR: openapi.Response(
 368             'error message',
 369             openapi.Schema(
 370                 type=openapi.TYPE_STRING))})
 371 @api_view(http_method_names=['DELETE', 'GET'])
 372 def nf_rd_csar(request, *args, **kwargs):
 373     csar_id = ignore_case_get(kwargs, "csarId")
 374     logger.info("Enter %s, method is %s, csar_id is %s",
 375                 fun_name(), request.method, csar_id)
 376     ret, normal_status, response_serializer, validation_error = None, None, None, None
 377
 378     if request.method == 'GET':
 379         ret = sdc_vnf_package.nf_get_csar(csar_id)
 380         normal_status = status.HTTP_200_OK
 381         response_serializer = NfPackageSerializer(data=ret[1])
 382
 383     elif request.method == 'DELETE':
 384         job_id = str(uuid.uuid4())
 385         sdc_vnf_package.NfPkgDeleteThread(csar_id, job_id).start()
 386         ret = [0, {"jobId": job_id}]
 387         normal_status = status.HTTP_202_ACCEPTED
 388         response_serializer = PostJobResponseSerializer(data=ret[1])
 389
 390     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 391     if ret[0] != 0:
 392         return Response(
 393             data={
 394                 'error': ret[1]},
 395             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 396
 397     validation_error = handleValidatonError(
 398         response_serializer, False)
 399     if validation_error:
 400         return validation_error
 401
 402     return Response(data=response_serializer.data, status=normal_status)
 403
 404
 405 @swagger_auto_schema(
 406     method='POST',
 407     operation_description="Parse model(NS, Service, VNF, PNF)",
 408     tags=["Parser API"],
 409     request_body=ParseModelRequestSerializer,
 410     responses={
 411         status.HTTP_202_ACCEPTED: ParseModelResponseSerializer,
 412         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 413 @api_view(http_method_names=['POST'])
 414 def model_parser(request, *args, **kwargs):
 415     csar_id = ignore_case_get(request.data, "csarId")
 416     package_type = ignore_case_get(request.data, "packageType")
 417     inputs = ignore_case_get(request.data, "inputs")
 418     logger.debug(
 419         "Enter %s, csar_id=%s, package_type=%s, inputs=%s",
 420         fun_name(),
 421         csar_id,
 422         package_type,
 423         inputs)
 424
 425     if package_type.lower().__eq__("service"):
 426         try:
 427             ret = ServicePackage().parse_serviced(csar_id, inputs)
 428             response_serializer = ParseModelResponseSerializer(data=ret)
 429             validation_error = handleValidatonError(
 430                 response_serializer, False)
 431             if validation_error:
 432                 return validation_error
 433             return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 434         except PackageNotFoundException as e:
 435             error_status = status.HTTP_404_NOT_FOUND
 436             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 437         except Exception as e:
 438             error_status = status.HTTP_500_INTERNAL_SERVER_ERROR
 439             return Response(data=fmt_error_rsp(e.args[0], error_status), status=error_status)
 440     elif package_type.lower().__eq__("ns"):
 441         ret = sdc_ns_package.parse_nsd(csar_id, inputs)
 442     elif package_type.lower().__eq__("vnf"):
 443         ret = sdc_vnf_package.parse_vnfd(csar_id, inputs)
 444     elif package_type.lower().__eq__("pnf"):
 445         ret = PnfDescriptor().parse_pnfd(csar_id, inputs)
 446     else:
 447         error_status = status.HTTP_400_BAD_REQUEST
 448         error_message = "Invalid package type, it should be one of [VNF, PNF, NS, Service]"
 449         return Response(data=fmt_error_rsp(error_message, error_status), status=error_status)
 450
 451     if ret[0] != 0:
 452         return Response(
 453             data={
 454                 'error': ret[1]},
 455             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 456
 457     response_serializer = ParseModelResponseSerializer(data=ret[1])
 458     validation_error = handleValidatonError(
 459         response_serializer, False)
 460     if validation_error:
 461         return validation_error
 462
 463     return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 464
 465
 466 @swagger_auto_schema(
 467     method='POST',
 468     operation_description="Parse NS model",
 469     tags=["Parser API"],
 470     request_body=ParseModelRequestSerializer,
 471     responses={
 472         status.HTTP_202_ACCEPTED: ParseModelResponseSerializer,
 473         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 474 @api_view(http_method_names=['POST'])
 475 def ns_model_parser(request, *args, **kwargs):
 476     csar_id = ignore_case_get(request.data, "csarId")
 477     inputs = ignore_case_get(request.data, "inputs")
 478     logger.debug(
 479         "Enter %s, csar_id=%s, inputs=%s",
 480         fun_name(),
 481         csar_id,
 482         inputs)
 483     ret = sdc_ns_package.parse_nsd(csar_id, inputs)
 484     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 485     if ret[0] != 0:
 486         return Response(
 487             data={
 488                 'error': ret[1]},
 489             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 490
 491     response_serializer = ParseModelResponseSerializer(data=ret[1])
 492     validation_error = handleValidatonError(
 493         response_serializer, False)
 494     if validation_error:
 495         return validation_error
 496
 497     return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 498
 499
 500 @swagger_auto_schema(
 501     method='POST',
 502     operation_description="Parse NF model",
 503     tags=["Parser API"],
 504     request_body=ParseModelRequestSerializer,
 505     responses={
 506         status.HTTP_202_ACCEPTED: ParseModelResponseSerializer,
 507         status.HTTP_500_INTERNAL_SERVER_ERROR: InternalErrorRequestSerializer})
 508 @api_view(http_method_names=['POST'])
 509 def vnf_model_parser(request, *args, **kwargs):
 510     csar_id = ignore_case_get(request.data, "csarId")
 511     inputs = ignore_case_get(request.data, "inputs")
 512     logger.debug(
 513         "Enter %s, csar_id=%s, inputs=%s",
 514         fun_name(),
 515         csar_id,
 516         inputs)
 517     ret = sdc_vnf_package.parse_vnfd(csar_id, inputs)
 518     logger.info("Leave %s, Return value is %s", fun_name(), ret)
 519     if ret[0] != 0:
 520         return Response(
 521             data={
 522                 'error': ret[1]},
 523             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 524
 525     response_serializer = ParseModelResponseSerializer(data=ret[1])
 526     validation_error = handleValidatonError(
 527         response_serializer, False)
 528     if validation_error:
 529         return validation_error
 530
 531     return Response(data=response_serializer.data, status=status.HTTP_202_ACCEPTED)
 532
 533
 534 def handleValidatonError(base_serializer, is_request):
 535     response = None
 536
 537     if not base_serializer.is_valid():
 538         errormessage = base_serializer.errors
 539         logger.error(errormessage)
 540
 541         if is_request:
 542             message = 'Invalid request'
 543         else:
 544             message = 'Invalid response'
 545         logger.error(message)
 546         response = Response(
 547             data={'error': errormessage},
 548             status=status.HTTP_500_INTERNAL_SERVER_ERROR)
 549
 550     return response