2 * Copyright © 2017-2018 AT&T Intellectual Property.
\r
3 * Modifications Copyright © 2018 IBM.
\r
5 * Licensed under the Apache License, Version 2.0 (the "License");
\r
6 * you may not use this file except in compliance with the License.
\r
7 * You may obtain a copy of the License at
\r
9 * http://www.apache.org/licenses/LICENSE-2.0
\r
11 * Unless required by applicable law or agreed to in writing, software
\r
12 * distributed under the License is distributed on an "AS IS" BASIS,
\r
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
\r
14 * See the License for the specific language governing permissions and
\r
15 * limitations under the License.
\r
18 package org.onap.ccsdk.apps.controllerblueprints.core.service
\r
21 import com.att.eelf.configuration.EELFLogger
\r
22 import com.att.eelf.configuration.EELFManager
\r
23 import com.fasterxml.jackson.databind.JsonNode
\r
24 import com.fasterxml.jackson.databind.node.NullNode
\r
25 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintConstants
\r
26 import org.onap.ccsdk.apps.controllerblueprints.core.BluePrintException
\r
27 import org.onap.ccsdk.apps.controllerblueprints.core.data.*
\r
28 import org.onap.ccsdk.apps.controllerblueprints.core.format
\r
29 import org.onap.ccsdk.apps.controllerblueprints.core.utils.JacksonUtils
\r
30 import org.onap.ccsdk.apps.controllerblueprints.core.utils.ResourceResolverUtils
\r
35 * @author Brinda Santh
\r
37 class PropertyAssignmentService(var bluePrintRuntimeService: BluePrintRuntimeService<MutableMap<String, JsonNode>>) {
\r
38 private val log: EELFLogger = EELFManager.getInstance().getLogger(this::class.toString())
\r
40 private var bluePrintContext: BluePrintContext = bluePrintRuntimeService.bluePrintContext()
\r
44 If Property Assignment is Expression.
\r
46 Recursively resolve the expression
\r
49 fun resolveAssignmentExpression(nodeTemplateName: String, assignmentName: String,
\r
50 assignment: JsonNode): JsonNode {
\r
51 val valueNode: JsonNode
\r
52 log.trace("Assignment ({})", assignment)
\r
53 val expressionData = BluePrintExpressionService.getExpressionData(assignment)
\r
55 if (expressionData.isExpression) {
\r
56 valueNode = resolveExpression(nodeTemplateName, assignmentName, expressionData)
\r
58 valueNode = expressionData.valueNode
\r
63 fun resolveExpression(nodeTemplateName: String, propName: String, expressionData: ExpressionData): JsonNode {
\r
65 var valueNode: JsonNode = NullNode.getInstance()
\r
67 if (expressionData.isExpression) {
\r
68 val command = expressionData.command!!
\r
71 BluePrintConstants.EXPRESSION_GET_INPUT -> {
\r
72 valueNode = bluePrintRuntimeService.getInputValue(expressionData.inputExpression?.propertyName!!)
\r
74 BluePrintConstants.EXPRESSION_GET_ATTRIBUTE -> {
\r
75 valueNode = resolveAttributeExpression(nodeTemplateName, expressionData.attributeExpression!!)
\r
77 BluePrintConstants.EXPRESSION_GET_PROPERTY -> {
\r
78 valueNode = resolvePropertyExpression(nodeTemplateName, expressionData.propertyExpression!!)
\r
80 BluePrintConstants.EXPRESSION_GET_OPERATION_OUTPUT -> {
\r
81 valueNode = resolveOperationOutputExpression(nodeTemplateName, expressionData.operationOutputExpression!!)
\r
83 BluePrintConstants.EXPRESSION_GET_ARTIFACT -> {
\r
84 valueNode = resolveArtifactExpression(nodeTemplateName, expressionData.artifactExpression!!)
\r
86 BluePrintConstants.EXPRESSION_GET_NODE_OF_TYPE -> {
\r
90 throw BluePrintException(format("for property ({}), command ({}) is not supported ", propName, command))
\r
98 get_property: [ <modelable_entity_name>, <optional_req_or_cap_name>, <property_name>,
\r
99 <nested_property_name_or_index_1>, ..., <nested_property_name_or_index_n> ]
\r
101 fun resolveAttributeExpression(nodeTemplateName: String, attributeExpression: AttributeExpression): JsonNode {
\r
102 val valueNode: JsonNode
\r
104 val attributeName = attributeExpression.attributeName
\r
105 val subAttributeName: String? = attributeExpression.subAttributeName
\r
107 var attributeNodeTemplateName = nodeTemplateName
\r
108 when (attributeExpression.modelableEntityName) {
\r
110 val environmentValue = System.getProperty(attributeName)
\r
111 valueNode = JacksonUtils.jsonNode(environmentValue)
\r
114 if (!attributeExpression.modelableEntityName.equals("SELF", true)) {
\r
115 attributeNodeTemplateName = attributeExpression.modelableEntityName
\r
117 /* Enable in ONAP Dublin Release
\r
118 val nodeTemplateAttributeExpression = bluePrintContext.nodeTemplateByName(attributeNodeTemplateName).attributes?.get(attributeName)
\r
119 ?: throw BluePrintException(format("failed to get attribute definitions for node template " +
\r
120 "({})'s property name ({}) ", nodeTemplateName, attributeName))
\r
122 var attributeDefinition: AttributeDefinition = bluePrintContext.nodeTemplateNodeType(attributeNodeTemplateName).attributes?.get(attributeName)!!
\r
124 log.info("node template name ({}), property Name ({}) resolved value ({})", attributeNodeTemplateName, attributeName, nodeTemplateAttributeExpression)
\r
127 valueNode = bluePrintRuntimeService.getNodeTemplateAttributeValue(attributeNodeTemplateName, attributeName)
\r
128 ?: throw BluePrintException(format("failed to get node template ({})'s attribute ({}) ", nodeTemplateName, attributeName))
\r
132 // subPropertyName?.let {
\r
133 // valueNode = valueNode.at(JsonPointer.valueOf(subPropertyName))
\r
139 get_property: [ <modelable_entity_name>, <optional_req_or_cap_name>, <property_name>,
\r
140 <nested_property_name_or_index_1>, ..., <nested_property_name_or_index_n> ]
\r
142 fun resolvePropertyExpression(nodeTemplateName: String, propertyExpression: PropertyExpression): JsonNode {
\r
143 val valueNode: JsonNode
\r
145 val propertyName = propertyExpression.propertyName
\r
146 val subPropertyName: String? = propertyExpression.subPropertyName
\r
148 var propertyNodeTemplateName = nodeTemplateName
\r
149 if (!propertyExpression.modelableEntityName.equals("SELF", true)) {
\r
150 propertyNodeTemplateName = propertyExpression.modelableEntityName
\r
153 val nodeTemplatePropertyExpression = bluePrintContext.nodeTemplateByName(propertyNodeTemplateName).properties?.get(propertyName)
\r
154 ?: throw BluePrintException(format("failed to get property definitions for node template ({})'s property name ({}) ", nodeTemplateName, propertyName))
\r
156 var propertyDefinition: PropertyDefinition = bluePrintContext.nodeTemplateNodeType(propertyNodeTemplateName).properties?.get(propertyName)!!
\r
158 log.info("node template name ({}), property Name ({}) resolved value ({})", propertyNodeTemplateName, propertyName, nodeTemplatePropertyExpression)
\r
160 // Check it it is a nested expression
\r
161 valueNode = resolveAssignmentExpression(propertyNodeTemplateName, propertyName, nodeTemplatePropertyExpression)
\r
163 // subPropertyName?.let {
\r
164 // valueNode = valueNode.at(JsonPointer.valueOf(subPropertyName))
\r
170 get_operation_output: <modelable_entity_name>, <interface_name>, <operation_name>, <output_variable_name>
\r
172 fun resolveOperationOutputExpression(nodeTemplateName: String, operationOutputExpression: OperationOutputExpression): JsonNode {
\r
173 var outputNodeTemplateName = nodeTemplateName
\r
174 if (!operationOutputExpression.modelableEntityName.equals("SELF", true)) {
\r
175 outputNodeTemplateName = operationOutputExpression.modelableEntityName
\r
177 return bluePrintRuntimeService.getNodeTemplateOperationOutputValue(outputNodeTemplateName,
\r
178 operationOutputExpression.interfaceName, operationOutputExpression.operationName,
\r
179 operationOutputExpression.propertyName)
\r
183 get_artifact: [ <modelable_entity_name>, <artifact_name>, <location>, <remove> ]
\r
185 fun resolveArtifactExpression(nodeTemplateName: String, artifactExpression: ArtifactExpression): JsonNode {
\r
187 var artifactNodeTemplateName = nodeTemplateName
\r
188 if (!artifactExpression.modelableEntityName.equals("SELF", true)) {
\r
189 artifactNodeTemplateName = artifactExpression.modelableEntityName
\r
191 val artifactDefinition: ArtifactDefinition = bluePrintContext.nodeTemplateByName(artifactNodeTemplateName)
\r
192 .artifacts?.get(artifactExpression.artifactName)
\r
193 ?: throw BluePrintException(format("failed to get artifact definitions for node template ({})'s " +
\r
194 "artifact name ({}) ", nodeTemplateName, artifactExpression.artifactName))
\r
196 return JacksonUtils.jsonNodeFromObject(artifactContent(artifactDefinition))
\r
199 fun artifactContent(artifactDefinition: ArtifactDefinition): String {
\r
200 val bluePrintBasePath: String = bluePrintContext.rootPath
\r
202 if (artifactDefinition.repository != null) {
\r
204 } else if (artifactDefinition.file != null) {
\r
205 return ResourceResolverUtils.getFileContent(artifactDefinition.file!!, bluePrintBasePath)
\r