aboutsummaryrefslogtreecommitdiffstats
path: root/openecomp-ui/.editorconfig
diff options
context:
space:
mode:
authorGitelman, Tal (tg851x) <tg851x@intl.att.com>2018-03-11 15:22:49 +0200
committerGitelman, Tal (tg851x) <tg851x@intl.att.com>2018-03-11 15:22:49 +0200
commit43ee1a6600efc01829c7d3a690a49567c27ca1d5 (patch)
tree9738d1a5261b31113f98992f18efd4d819c4417b /openecomp-ui/.editorconfig
parentc51b62ce234073ac2f801ae8ec229d168dcb6392 (diff)
Sync Integ to Master
Change-Id: Ia569fd6081e5f0abf60d0e8cef577dad514c6b82 Issue-ID: SDC-977 Signed-off-by: Gitelman, Tal (tg851x) <tg851x@intl.att.com>
Diffstat (limited to 'openecomp-ui/.editorconfig')
0 files changed, 0 insertions, 0 deletions
9 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 
/*
 * Copyright © 2017-2018 AT&T Intellectual Property.
 * Modifications Copyright © 2019 IBM.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.onap.ccsdk.cds.blueprintsprocessor.selfservice.api

import io.grpc.Status
import io.grpc.stub.StreamObserver
import kotlinx.coroutines.runBlocking
import org.onap.ccsdk.cds.blueprintsprocessor.core.BluePrintCoreConfiguration
import org.onap.ccsdk.cds.blueprintsprocessor.core.utils.toJava
import org.onap.ccsdk.cds.blueprintsprocessor.grpc.service.mdcGrpcCoroutineScope
import org.onap.ccsdk.cds.controllerblueprints.core.BluePrintProcessorException
import org.onap.ccsdk.cds.controllerblueprints.processing.api.BluePrintProcessingServiceGrpc
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceInput
import org.onap.ccsdk.cds.controllerblueprints.processing.api.ExecutionServiceOutput
import org.onap.ccsdk.cds.error.catalog.core.ErrorCatalogCodes
import org.onap.ccsdk.cds.error.catalog.core.utils.errorCauseOrDefault
import org.onap.ccsdk.cds.error.catalog.core.utils.errorMessageOrDefault
import org.onap.ccsdk.cds.error.catalog.services.ErrorCatalogService
import org.slf4j.LoggerFactory
import org.springframework.security.access.prepost.PreAuthorize
import org.springframework.stereotype.Service
import java.util.concurrent.Phaser
import javax.annotation.PreDestroy

@Service
open class BluePrintProcessingGRPCHandler(
    private val bluePrintCoreConfiguration: BluePrintCoreConfiguration,
    private val executionServiceHandler: ExecutionServiceHandler,
    private val errorCatalogService: ErrorCatalogService
) :
    BluePrintProcessingServiceGrpc.BluePrintProcessingServiceImplBase() {

    private val log = LoggerFactory.getLogger(BluePrintProcessingGRPCHandler::class.java)

    private val ph = Phaser(1)

    @PreAuthorize("hasRole('USER')")
    override fun process(
        responseObserver: StreamObserver<ExecutionServiceOutput>
    ): StreamObserver<ExecutionServiceInput> {

        return object : StreamObserver<ExecutionServiceInput> {
            override fun onNext(executionServiceInput: ExecutionServiceInput) {
                try {
                    ph.register()
                    runBlocking {
                        mdcGrpcCoroutineScope(executionServiceInput) {
                            executionServiceHandler.process(executionServiceInput.toJava(), responseObserver)
                        }
                    }
                } catch (e: Exception) {
                    if (e is BluePrintProcessorException) handleWithErrorCatalog(e) else handleError(e)
                } finally {
                    ph.arriveAndDeregister()
                }
            }

            override fun onError(error: Throwable) {
                log.error("Terminating stream error:", error)
            }

            fun handleError(error: Exception) {
                responseObserver.onError(
                    Status.INTERNAL
                        .withDescription(error.errorMessageOrDefault())
                        .withCause(error.errorCauseOrDefault())
                        .asException()
                )
            }

            fun handleWithErrorCatalog(error: BluePrintProcessorException) {
                if (error.protocol == "") {
                    error.grpc(ErrorCatalogCodes.GENERIC_FAILURE)
                }
                val errorPayload = errorCatalogService.errorPayload(error)
                val grpcCode = Status.fromCodeValue(errorPayload.code)
                responseObserver.onError(
                    grpcCode
                        .withDescription(errorPayload.message)
                        .withCause(error.errorCauseOrDefault())
                        .asException()
                )
            }

            override fun onCompleted() {
                log.info("Completed")
            }
        }
    }

    @PreDestroy
    fun preDestroy() {
        val name = "BluePrintProcessingGRPCHandler"
        log.info("Starting to shutdown $name waiting for in-flight requests to finish ...")
        ph.arriveAndAwaitAdvance()
        log.info("Done waiting in $name")
    }
}