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 org.apache.commons.io.FilenameUtils
  21 import org.apache.commons.lang3.text.StrBuilder
  22 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
  23 import org.onap.ccsdk.apps.controllerblueprints.core.data.ArtifactType
  24 import org.onap.ccsdk.apps.controllerblueprints.core.data.DataType
  25 import org.onap.ccsdk.apps.controllerblueprints.core.data.NodeType
  26 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
  27 import org.onap.ccsdk.apps.controllerblueprints.service.ModelTypeService
  28 import org.onap.ccsdk.apps.controllerblueprints.service.domain.ModelType
  29 import org.springframework.stereotype.Service
  30 import java.io.File
  31 import java.nio.charset.Charset
  32
  33 @Service
  34 open class ModelTypeLoadService(private val modelTypeService: ModelTypeService) {
  35
  36     private val log = EELFManager.getInstance().getLogger(ModelTypeLoadService::class.java)
  37     private val updateBySystem = "System"
  38
  39     open fun loadPathsModelType(modelTypePaths: List<String>) {
  40         modelTypePaths.forEach { loadPathModelType(it) }
  41     }
  42
  43     open fun loadPathModelType(modelTypePath: String) {
  44         log.info(" *************************** loadModelType **********************")
  45         try {
  46             val errorBuilder = StrBuilder()
  47
  48             val dataTypeFiles = File("$modelTypePath/data_type").listFiles()
  49             dataTypeFiles.forEach { loadDataType(it, errorBuilder) }
  50
  51             val artifactTypefiles = File("$modelTypePath/artifact_type").listFiles()
  52             artifactTypefiles.forEach { loadArtifactType(it, errorBuilder) }
  53
  54             val nodeTypeFiles = File("$modelTypePath/node_type").listFiles()
  55             nodeTypeFiles.forEach { loadNodeType(it, errorBuilder) }
  56
  57             if (!errorBuilder.isEmpty) {
  58                 log.error(errorBuilder.toString())
  59             }
  60         } catch (e: Exception) {
  61             log.error("Failed to loade ModelTypes under($modelTypePath)", e)
  62         }
  63     }
  64
  65     private fun loadDataType(file: File, errorBuilder: StrBuilder) {
  66         try {
  67             log.trace("Loading DataType(${file.name}")
  68             val dataKey = FilenameUtils.getBaseName(file.name)
  69             val definitionContent = file.readText(Charset.defaultCharset())
  70             val dataType = JacksonUtils.readValue(definitionContent, DataType::class.java)
  71             checkNotNull(dataType) { "failed to get data type from file : ${file.name}" }
  72
  73             val modelType = ModelType()
  74             modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE
  75             modelType.derivedFrom = dataType.derivedFrom
  76             modelType.description = dataType.description
  77             modelType.definition = JacksonUtils.jsonNode(definitionContent)
  78             modelType.modelName = dataKey
  79             modelType.version = dataType.version
  80             modelType.updatedBy = updateBySystem
  81             modelType.tags = (dataKey + "," + dataType.derivedFrom + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_DATA_TYPE)
  82             modelTypeService.saveModel(modelType)
  83             log.trace("DataType(${file.name}) loaded successfully ")
  84         } catch (e: Exception) {
  85             errorBuilder.appendln("Couldn't load DataType(${file.name}: ${e.message}")
  86         }
  87     }
  88
  89     private fun loadArtifactType(file: File, errorBuilder: StrBuilder) {
  90         try {
  91             log.trace("Loading ArtifactType(${file.name}")
  92             val dataKey = FilenameUtils.getBaseName(file.name)
  93             val definitionContent = file.readText(Charset.defaultCharset())
  94             val artifactType = JacksonUtils.readValue(definitionContent, ArtifactType::class.java)
  95             checkNotNull(artifactType) { "failed to get artifact type from file : ${file.name}" }
  96
  97             val modelType = ModelType()
  98             modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE
  99             modelType.derivedFrom = artifactType.derivedFrom
 100             modelType.description = artifactType.description
 101             modelType.definition = JacksonUtils.jsonNode(definitionContent)
 102             modelType.modelName = dataKey
 103             modelType.version = artifactType.version
 104             modelType.updatedBy = updateBySystem
 105             modelType.tags = (dataKey + "," + artifactType.derivedFrom + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_ARTIFACT_TYPE)
 106             modelTypeService.saveModel(modelType)
 107             log.trace("ArtifactType(${file.name}) loaded successfully ")
 108         } catch (e: Exception) {
 109             errorBuilder.appendln("Couldn't load ArtifactType(${file.name}: ${e.message}")
 110         }
 111     }
 112
 113     private fun loadNodeType(file: File, errorBuilder: StrBuilder) {
 114         try {
 115             log.trace("Loading NodeType(${file.name}")
 116             val nodeKey = FilenameUtils.getBaseName(file.name)
 117             val definitionContent = file.readText(Charset.defaultCharset())
 118             val nodeType = JacksonUtils.readValue(definitionContent, NodeType::class.java)
 119             checkNotNull(nodeType) { "failed to get node type from file : ${file.name}" }
 120
 121             val modelType = ModelType()
 122             modelType.definitionType = BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE
 123             modelType.derivedFrom = nodeType.derivedFrom
 124             modelType.description = nodeType.description
 125             modelType.definition = JacksonUtils.jsonNode(definitionContent)
 126             modelType.modelName = nodeKey
 127             modelType.version = nodeType.version
 128             modelType.updatedBy = updateBySystem
 129             modelType.tags = (nodeKey + "," + BluePrintConstants.MODEL_DEFINITION_TYPE_NODE_TYPE + "," + nodeType.derivedFrom)
 130             modelTypeService.saveModel(modelType)
 131             log.trace("NodeType(${file.name}) loaded successfully ")
 132         } catch (e: Exception) {
 133             errorBuilder.appendln("Couldn't load NodeType(${file.name}: ${e.message}")
 134         }
 135     }
 136
 137 }