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