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

   1 /*
   2  * Copyright © 2017-2018 AT&T Intellectual Property.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package org.onap.ccsdk.apps.controllerblueprints.service.load
  18
  19 import com.att.eelf.configuration.EELFManager
  20 import kotlinx.coroutines.*
  21 import org.apache.commons.io.FilenameUtils
  22 import org.apache.commons.lang3.text.StrBuilder
  23 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
  24 import org.onap.ccsdk.apps.controllerblueprints.core.data.ArtifactType
  25 import org.onap.ccsdk.apps.controllerblueprints.core.data.DataType
  26 import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType
  27 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
  28 import org.onap.ccsdk.apps.controllerblueprints.service.ModelTypeService
  29 import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
  30 import org.springframework.stereotype.Service
  31 import java.io.File
  32 import java.nio.charset.Charset
  33
  34 @Service
  35 open class ModelTypeLoadService(private val modelTypeService: ModelTypeService) {
  36
  37     private val log = EELFManager.getInstance().getLogger(ModelTypeLoadService::class.java)
  38     private val updateBySystem = "System"
  39
  40     open fun loadPathsModelType(modelTypePaths: List<String>) {
  41         modelTypePaths.forEach { loadPathModelType(it) }
  42     }
  43
  44     open fun loadPathModelType(modelTypePath: String) = runBlocking {
  45         log.info(" *************************** loadModelType **********************")
  46         try {
  47             val errorBuilder = StrBuilder()
  48
  49             coroutineScope {
  50                 val dataTypeFiles = File("$modelTypePath/data_type").listFiles()
  51
  52                 val deferredResults = mutableListOf<Deferred<Unit>>()
  53
  54                 for (file in dataTypeFiles) deferredResults += async { loadDataType(file, errorBuilder) }
  55
  56                 deferredResults.awaitAll()
  57             }
  58
  59             coroutineScope {
  60                 val artifactTypefiles = File("$modelTypePath/artifact_type").listFiles()
  61
  62                 val deferredResults = mutableListOf<Deferred<Unit>>()
  63
  64                 for (file in artifactTypefiles) deferredResults += async { loadArtifactType(file, errorBuilder) }
  65
  66                 deferredResults.awaitAll()
  67             }
  68
  69             coroutineScope {
  70                 val nodeTypeFiles = File("$modelTypePath/node_type").listFiles()
  71
  72                 val deferredResults = mutableListOf<Deferred<Unit>>()
  73
  74                 for (file in nodeTypeFiles) deferredResults += async { loadNodeType(file, errorBuilder) }
  75                 deferredResults.awaitAll()
  76             }
  77
  78             if (!errorBuilder.isEmpty) {
  79                 log.error(errorBuilder.toString())
  80             }
  81         } catch (e: Exception) {
  82             log.error("Failed to loade ModelTypes under($modelTypePath)", e)
  83         }
  84     }
  85
  86     private fun loadDataType(file: File, errorBuilder: StrBuilder) {
  87         try {
  88             log.trace("Loading DataType(${file.name}")
  89             val dataKey = FilenameUtils.getBaseName(file.name)
  90             val definitionContent = file.readText(Charset.defaultCharset())
  91             val dataType = JacksonUtils.readValue(definitionContent, DataType::class.java)
  92             checkNotNull(dataType) { "failed to get data type from file : ${file.name}" }
  93
  94             val modelType = ModelType()
  95             modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
  96             modelType.derivedFrom = dataType.derivedFrom
  97             modelType.description = dataType.description
  98             modelType.definition = JacksonUtils.jsonNode(definitionContent)
  99             modelType.modelName = dataKey
 100             modelType.version = dataType.version
 101             modelType.updatedBy = updateBySystem
 102             modelType.tags = (dataKey + "," + dataType.derivedFrom + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
 103             modelTypeService.saveModel(modelType)
 104             log.trace("DataType(${file.name}) loaded successfully ")
 105         } catch (e: Exception) {
 106             errorBuilder.appendln("Couldn't load DataType(${file.name}: ${e.message}")
 107         }
 108     }
 109
 110     private fun loadArtifactType(file: File, errorBuilder: StrBuilder) {
 111         try {
 112             log.trace("Loading ArtifactType(${file.name}")
 113             val dataKey = FilenameUtils.getBaseName(file.name)
 114             val definitionContent = file.readText(Charset.defaultCharset())
 115             val artifactType = JacksonUtils.readValue(definitionContent, ArtifactType::class.java)
 116             checkNotNull(artifactType) { "failed to get artifact type from file : ${file.name}" }
 117
 118             val modelType = ModelType()
 119             modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE
 120             modelType.derivedFrom = artifactType.derivedFrom
 121             modelType.description = artifactType.description
 122             modelType.definition = JacksonUtils.jsonNode(definitionContent)
 123             modelType.modelName = dataKey
 124             modelType.version = artifactType.version
 125             modelType.updatedBy = updateBySystem
 126             modelType.tags = (dataKey + "," + artifactType.derivedFrom + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE)
 127             modelTypeService.saveModel(modelType)
 128             log.trace("ArtifactType(${file.name}) loaded successfully ")
 129         } catch (e: Exception) {
 130             errorBuilder.appendln("Couldn't load ArtifactType(${file.name}: ${e.message}")
 131         }
 132     }
 133
 134     private fun loadNodeType(file: File, errorBuilder: StrBuilder) {
 135         try {
 136             log.trace("Loading NodeType(${file.name}")
 137             val nodeKey = FilenameUtils.getBaseName(file.name)
 138             val definitionContent = file.readText(Charset.defaultCharset())
 139             val nodeType = JacksonUtils.readValue(definitionContent, NodeType::class.java)
 140             checkNotNull(nodeType) { "failed to get node type from file : ${file.name}" }
 141
 142             val modelType = ModelType()
 143             modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE
 144             modelType.derivedFrom = nodeType.derivedFrom
 145             modelType.description = nodeType.description
 146             modelType.definition = JacksonUtils.jsonNode(definitionContent)
 147             modelType.modelName = nodeKey
 148             modelType.version = nodeType.version
 149             modelType.updatedBy = updateBySystem
 150             modelType.tags = (nodeKey + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE + "," + nodeType.derivedFrom)
 151             modelTypeService.saveModel(modelType)
 152             log.trace("NodeType(${file.name}) loaded successfully ")
 153         } catch (e: Exception) {
 154             errorBuilder.appendln("Couldn't load NodeType(${file.name}: ${e.message}")
 155         }
 156     }
 157
 158 }