gerrit.onap Code Review - ccsdk/cds.git/blob

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  * Modifications Copyright © 2019 Bell Canada.
   4  * Modifications Copyright © 2019 IBM.
   5  *
   6  * Licensed under the Apache License, Version 2.0 (the "License");
   7  * you may not use this file except in compliance with the License.
   8  * You may obtain a copy of the License at
   9  *
  10  *     http://www.apache.org/licenses/LICENSE-2.0
  11  *
  12  * Unless required by applicable law or agreed to in writing, software
  13  * distributed under the License is distributed on an "AS IS" BASIS,
  14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15  * See the License for the specific language governing permissions and
  16  * limitations under the License.
  17  */
  18
  19 package org.onap.ccsdk.cds.blueprintsprocessor.designer.api
  20
  21 import com.google.protobuf.ByteString
  22 import com.google.protobuf.util.JsonFormat
  23 import io.grpc.stub.StreamObserver
  24 import kotlinx.coroutines.runBlocking
  25 import org.onap.ccsdk.cds.blueprintsprocessor.designer.api.handler.BluePrintModelHandler
  26 import org.onap.ccsdk.cds.controllerblueprints.common.api.CommonHeader
  27 import org.onap.ccsdk.cds.controllerblueprints.common.api.Status
  28 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintConstants
  29 import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
  30 import org.onap.ccsdk.cds.controllerblueprints.core.asJsonString
  31 import org.onap.ccsdk.cds.controllerblueprints.core.emptyTONull
  32 import org.onap.ccsdk.cds.controllerblueprints.core.utils.currentTimestamp
  33 import org.onap.ccsdk.cds.controllerblueprints.management.api.*
  34 import org.slf4j.LoggerFactory
  35 import org.springframework.security.access.prepost.PreAuthorize
  36 import org.springframework.stereotype.Service
  37
  38 //TODO("Convert to coroutines handler")
  39 @Service
  40 open class BluePrintManagementGRPCHandler(private val bluePrintModelHandler: BluePrintModelHandler)
  41     : BluePrintManagementServiceGrpc.BluePrintManagementServiceImplBase() {
  42
  43     private val log = LoggerFactory.getLogger(BluePrintManagementGRPCHandler::class.java)
  44
  45     @PreAuthorize("hasRole('USER')")
  46     override fun uploadBlueprint(request: BluePrintUploadInput, responseObserver:
  47     StreamObserver<BluePrintManagementOutput>) {
  48
  49         runBlocking {
  50             //TODO("catch if request id is missing")
  51             log.info("request(${request.commonHeader.requestId})")
  52             try {
  53                 /** Get the file byte array */
  54                 val byteArray = request.fileChunk.chunk.toByteArray()
  55                 /** Get the Upload Action */
  56                 val uploadAction = request.actionIdentifiers?.actionName.emptyTONull()
  57                         ?: UploadAction.DRAFT.toString()
  58
  59                 when (uploadAction) {
  60                     UploadAction.DRAFT.toString() -> {
  61                         val blueprintModel = bluePrintModelHandler.upload(byteArray, false)
  62                         responseObserver.onNext(successStatus(request.commonHeader, blueprintModel.asJsonString()))
  63                     }
  64                     UploadAction.PUBLISH.toString() -> {
  65                         val blueprintModel = bluePrintModelHandler.upload(byteArray, true)
  66                         responseObserver.onNext(successStatus(request.commonHeader, blueprintModel.asJsonString()))
  67                     }
  68                     UploadAction.VALIDATE.toString() -> {
  69                         //TODO("Not Implemented")
  70                         responseObserver.onNext(failStatus(request.commonHeader,
  71                                 "Upload action($uploadAction) not implemented",
  72                                 BluePrintProcessorException("Not Implemented")))
  73                     }
  74                     UploadAction.ENRICH.toString() -> {
  75                         val enrichedByteArray = bluePrintModelHandler.enrichBlueprintFileSource(byteArray)
  76                         responseObserver.onNext(enrichmentStatus(request.commonHeader, enrichedByteArray))
  77                     }
  78                     else -> {
  79                         responseObserver.onNext(failStatus(request.commonHeader,
  80                                 "Upload action($uploadAction) not implemented",
  81                                 BluePrintProcessorException("Not implemented")))
  82                     }
  83                 }
  84             } catch (e: Exception) {
  85                 responseObserver.onNext(failStatus(request.commonHeader,
  86                         "request(${request.commonHeader.requestId}): Failed to upload CBA", e))
  87             } finally {
  88                 responseObserver.onCompleted()
  89             }
  90         }
  91     }
  92
  93     @PreAuthorize("hasRole('USER')")
  94     override fun removeBlueprint(request: BluePrintRemoveInput, responseObserver:
  95     StreamObserver<BluePrintManagementOutput>) {
  96
  97         runBlocking {
  98             val blueprintName = request.blueprintName
  99             val blueprintVersion = request.blueprintVersion
 100             val blueprint = "blueprint $blueprintName:$blueprintVersion"
 101
 102             log.info("request(${request.commonHeader.requestId}): Received delete $blueprint")
 103             try {
 104                 bluePrintModelHandler.deleteBlueprintModel(blueprintName, blueprintVersion)
 105                 responseObserver.onNext(successStatus(request.commonHeader))
 106             } catch (e: Exception) {
 107                 responseObserver.onNext(failStatus(request.commonHeader,
 108                         "request(${request.commonHeader.requestId}): Failed to delete $blueprint", e))
 109             } finally {
 110                 responseObserver.onCompleted()
 111             }
 112         }
 113     }
 114
 115     private fun enrichmentStatus(header: CommonHeader, byteArray: ByteArray): BluePrintManagementOutput =
 116             BluePrintManagementOutput.newBuilder()
 117                     .setCommonHeader(header)
 118                     .setFileChunk(FileChunk.newBuilder().setChunk(ByteString.copyFrom(byteArray)))
 119                     .setStatus(Status.newBuilder()
 120                             .setTimestamp(currentTimestamp())
 121                             .setMessage(BluePrintConstants.STATUS_SUCCESS)
 122                             .setCode(200)
 123                             .build())
 124                     .build()
 125
 126     private fun successStatus(header: CommonHeader, propertyContent: String? = null): BluePrintManagementOutput {
 127         // Populate Response Payload
 128         val propertiesBuilder = BluePrintManagementOutput.newBuilder().propertiesBuilder
 129         propertyContent?.let {
 130             JsonFormat.parser().merge(propertyContent, propertiesBuilder)
 131         }
 132         return BluePrintManagementOutput.newBuilder()
 133                 .setCommonHeader(header)
 134                 .setProperties(propertiesBuilder.build())
 135                 .setStatus(Status.newBuilder()
 136                         .setTimestamp(currentTimestamp())
 137                         .setMessage(BluePrintConstants.STATUS_SUCCESS)
 138                         .setCode(200)
 139                         .build())
 140                 .build()
 141     }
 142
 143     private fun failStatus(header: CommonHeader, message: String, e: Exception): BluePrintManagementOutput {
 144         log.error(message, e)
 145         return BluePrintManagementOutput.newBuilder()
 146                 .setCommonHeader(header)
 147                 .setStatus(Status.newBuilder()
 148                         .setTimestamp(currentTimestamp())
 149                         .setMessage(BluePrintConstants.STATUS_FAILURE)
 150                         .setErrorMessage(message)
 151                         .setCode(500)
 152                         .build())
 153                 .build()
 154 //        return io.grpc.Status.INTERNAL
 155 //                .withDescription(message)
 156 //                .withCause(e)
 157 //                .asException()
 158     }
 159 }