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