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.features.model.utils;
\r
20 import java.util.Map;
\r
21 import org.apache.commons.collections.MapUtils;
\r
22 import org.apache.commons.lang3.StringUtils;
\r
23 import org.onap.ccsdk.features.model.ConfigModelConstant;
\r
24 import org.onap.ccsdk.features.model.data.InterfaceAssignment;
\r
25 import org.onap.ccsdk.features.model.data.InterfaceDefinition;
\r
26 import org.onap.ccsdk.features.model.data.NodeTemplate;
\r
27 import org.onap.ccsdk.features.model.data.NodeType;
\r
28 import org.onap.ccsdk.features.model.data.OperationAssignment;
\r
29 import org.onap.ccsdk.features.model.data.OperationDefinition;
\r
30 import org.onap.ccsdk.features.model.data.ServiceTemplate;
\r
31 import org.onap.ccsdk.features.model.data.TopologyTemplate;
\r
32 import org.onap.ccsdk.sli.core.sli.SvcLogicContext;
\r
33 import com.att.eelf.configuration.EELFLogger;
\r
34 import com.att.eelf.configuration.EELFManager;
\r
36 public class ServiceTemplateUtils {
\r
37 private static EELFLogger logger = EELFManager.getInstance().getLogger(ServiceTemplateUtils.class);
\r
39 public Map<String, String> convertServiceTemplate2Properties(String serviceTemplateContent,
\r
40 final Map<String, String> context) {
\r
41 if (StringUtils.isNotBlank(serviceTemplateContent)) {
\r
42 ServiceTemplate serviceTemplate =
\r
43 TransformationUtils.readValue(serviceTemplateContent, ServiceTemplate.class);
\r
44 convertServiceTemplate2Properties(serviceTemplate, context);
\r
49 public Map<String, String> convertServiceTemplate2Properties(ServiceTemplate serviceTemplate,
\r
50 final Map<String, String> context) {
\r
51 if (serviceTemplate != null) {
\r
52 convertServiceTemplateMetadata2Properties(serviceTemplate, context);
\r
53 convertServiceTemplateInputs2Properties(serviceTemplate, context);
\r
54 convertDataTypes2Properties(serviceTemplate, context);
\r
55 convertNode2Properties(serviceTemplate, context);
\r
60 public Map<String, String> convertServiceTemplateMetadata2Properties(ServiceTemplate serviceTemplate,
\r
61 final Map<String, String> context) {
\r
63 if (serviceTemplate != null && serviceTemplate.getMetadata() != null) {
\r
64 serviceTemplate.getMetadata().forEach((metaDataKey, metadata) -> {
\r
65 context.put(metaDataKey, metadata);
\r
71 public Map<String, String> convertServiceTemplateInputs2Properties(ServiceTemplate serviceTemplate,
\r
72 final Map<String, String> context) {
\r
74 if (serviceTemplate != null && serviceTemplate.getTopologyTemplate() != null
\r
75 && serviceTemplate.getTopologyTemplate().getInputs() != null) {
\r
77 serviceTemplate.getTopologyTemplate().getInputs().forEach((paramKey, parameterDefinition) -> {
\r
78 if (parameterDefinition != null) {
\r
79 context.put(ConfigModelConstant.PROPERTY_INPUTS_DOT + paramKey + ".type",
\r
80 parameterDefinition.getType());
\r
81 if (parameterDefinition.getRequired()) {
\r
82 context.put(ConfigModelConstant.PROPERTY_INPUTS_DOT + paramKey + ".required",
\r
83 String.valueOf(parameterDefinition.getRequired()));
\r
85 if (parameterDefinition.getDefaultValue() != null) {
\r
86 context.put(ConfigModelConstant.PROPERTY_INPUTS_DOT + paramKey + ".default",
\r
87 String.valueOf(parameterDefinition.getDefaultValue()));
\r
95 public Map<String, String> convertDataTypes2Properties(ServiceTemplate serviceTemplate,
\r
96 final Map<String, String> context) {
\r
97 if (serviceTemplate != null && serviceTemplate.getDataTypes() != null) {
\r
98 serviceTemplate.getDataTypes().forEach((dataTypeKey, dataType) -> {
\r
99 logger.trace("Populating Data Type Key : ({})", dataTypeKey);
\r
100 String dataTypeContent = TransformationUtils.getJson(dataType);
\r
101 context.put("data_types." + dataTypeKey, dataTypeContent);
\r
107 public Map<String, String> convertNode2Properties(ServiceTemplate serviceTemplate,
\r
108 final Map<String, String> context) {
\r
110 if (serviceTemplate != null && serviceTemplate.getNodeTypes() != null
\r
111 && serviceTemplate.getTopologyTemplate() != null
\r
112 && serviceTemplate.getTopologyTemplate().getNodeTemplates() != null) {
\r
114 serviceTemplate.getTopologyTemplate().getNodeTemplates().forEach((nodeTemplateKey, nodeTemplate) -> {
\r
115 if (nodeTemplate != null && StringUtils.isNotBlank(nodeTemplate.getType())) {
\r
116 String nodeTypeKey = nodeTemplate.getType();
\r
117 logger.trace("Populating Node Type Key : ({}) for Node Template : ({})", nodeTypeKey,
\r
119 String nodeTemplateContent = TransformationUtils.getJson(nodeTemplate);
\r
120 context.put("node_templates." + nodeTemplateKey, nodeTemplateContent);
\r
121 if (serviceTemplate.getNodeTypes().containsKey(nodeTypeKey)) {
\r
122 NodeType nodeType = serviceTemplate.getNodeTypes().get(nodeTypeKey);
\r
123 String nodeTypeContent = TransformationUtils.getJson(nodeType);
\r
124 context.put("node_types." + nodeTypeKey, nodeTypeContent);
\r
125 String nodeDerivedFrom = nodeType.getDerivedFrom();
\r
126 if (ConfigModelConstant.MODEL_TYPE_NODE_DG.equalsIgnoreCase(nodeDerivedFrom)) {
\r
127 populateDGNodeProperties(nodeTemplateKey, nodeTemplate, context, nodeDerivedFrom);
\r
130 // Populate the Artifact Definitions
\r
131 populateNodeTemplateArtifacts(nodeTemplateKey, nodeTemplate, context);
\r
138 @SuppressWarnings("squid:S1172")
\r
139 public Map<String, String> populateVnfNodeProperties(String nodeTemplateKey, NodeTemplate nodeTemplate,
\r
140 final Map<String, String> context, String nodeDerivedFrom) {
\r
141 if (nodeTemplate != null && nodeTemplate.getCapabilities() != null) {
\r
142 nodeTemplate.getCapabilities().forEach((capabilityKey, capability) -> {
\r
143 capability.getProperties().forEach((propertyKey, property) -> {
\r
144 context.put(nodeTemplateKey + "." + capabilityKey + "." + propertyKey, String.valueOf(property));
\r
152 public Map<String, String> populateNodeTemplateArtifacts(String nodeTemplateKey, NodeTemplate nodeTemplate,
\r
153 final Map<String, String> context) {
\r
154 if (MapUtils.isNotEmpty(nodeTemplate.getArtifacts())) {
\r
155 nodeTemplate.getArtifacts().forEach((artifactName, artifact) -> {
\r
156 if (StringUtils.isNotBlank(artifactName) && artifact != null) {
\r
157 logger.trace("Populating Node Template Artifacts ({}) for Node Template ({})", artifactName,
\r
159 String fileKeyName = ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateKey + "."
\r
160 + ConfigModelConstant.PROPERTY_ARTIFACTS_DOT + artifactName + ".file";
\r
161 String deployKeyName = ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateKey + "."
\r
162 + ConfigModelConstant.PROPERTY_ARTIFACTS_DOT + artifactName + ".deploy_path";
\r
163 String contentKeyName = ConfigModelConstant.PROPERTY_NODE_TEMPLATES_DOT + nodeTemplateKey + "."
\r
164 + ConfigModelConstant.PROPERTY_ARTIFACTS_DOT + artifactName + ".content";
\r
165 context.put(fileKeyName, artifact.getFile());
\r
166 context.put(deployKeyName, artifact.getDeployPath());
\r
167 context.put(contentKeyName, artifact.getContent());
\r
174 public Map<String, String> populateDGNodeProperties(String nodeTemplateKey, NodeTemplate nodeTemplate,
\r
175 final Map<String, String> context, String nodeDerivedFrom) {
\r
176 if (nodeTemplate != null && nodeTemplate.getInterfaces() != null) {
\r
178 if (nodeTemplate.getProperties() != null) {
\r
179 nodeTemplate.getProperties().forEach((propKey, propValue) -> {
\r
180 if (propKey != null && propValue != null) {
\r
181 context.put("dg." + nodeTemplateKey + "." + propKey, String.valueOf(propValue));
\r
186 nodeTemplate.getInterfaces().forEach((interfaceKey, interfaceDefinition) -> {
\r
188 interfaceDefinition.getOperations().forEach((operationKey, operation) -> {
\r
189 if (ConfigModelConstant.MODEL_TYPE_NODE_DG.equalsIgnoreCase(nodeDerivedFrom)) {
\r
190 context.put("dg." + nodeTemplateKey + ".module", interfaceKey);
\r
191 context.put("dg." + nodeTemplateKey + ".flow", operationKey);
\r
199 public SvcLogicContext getInterfaceOpertationDefinition(ServiceTemplate serviceTemplate,
\r
200 final SvcLogicContext context) {
\r
202 if (serviceTemplate != null && serviceTemplate.getNodeTypes() != null
\r
203 && serviceTemplate.getTopologyTemplate() != null
\r
204 && serviceTemplate.getTopologyTemplate().getNodeTemplates() != null) {
\r
206 TopologyTemplate topologyTemplates = serviceTemplate.getTopologyTemplate();
\r
207 // Copy Definition to Template
\r
208 copyNodeType2Template(serviceTemplate.getNodeTypes(), topologyTemplates.getNodeTemplates());
\r
210 topologyTemplates.getNodeTemplates().forEach((templateKey, nodeTemplate) -> {
\r
212 if (StringUtils.isNotBlank(templateKey) && nodeTemplate != null
\r
213 && nodeTemplate.getInterfaces() != null) {
\r
215 nodeTemplate.getInterfaces().forEach((interfaceKey, interfaceDefinition) -> {
\r
216 if (StringUtils.isNotBlank(interfaceKey) && interfaceDefinition != null) {
\r
217 interfaceDefinition.getOperations().forEach((operationKey, operation) -> {
\r
218 String definitionKey = interfaceKey + "." + operationKey;
\r
219 String definitionContent = TransformationUtils.getJson(operation);
\r
220 context.setAttribute(definitionKey, definitionContent);
\r
221 // Set the Operation & Method Params
\r
231 public void copyNodeType2Template(Map<String, NodeType> nodeTypes, Map<String, NodeTemplate> nodeTemplates) {
\r
232 if (nodeTypes != null && nodeTemplates != null) {
\r
234 nodeTemplates.forEach((templateKey, nodeTemplate) -> {
\r
235 if (StringUtils.isNotBlank(templateKey) && nodeTemplate != null) {
\r
236 String type = nodeTemplate.getType();
\r
237 // Check the Node Template Type is Present
\r
238 if (StringUtils.isNotBlank(type) && nodeTypes.containsKey(type)) {
\r
239 NodeType nodeType = nodeTypes.get(type);
\r
240 logger.trace("Checking Node Type Content : ({})", TransformationUtils.getJson(nodeType));
\r
241 copyNodeTypeInterface2Template(nodeType.getInterfaces(), nodeTemplate.getInterfaces());
\r
248 public void copyNodeTypeInterface2Template(Map<String, InterfaceDefinition> nodeTypeInterfaces,
\r
249 Map<String, InterfaceAssignment> nodeTemplateInterfaces) {
\r
250 if (nodeTypeInterfaces != null && nodeTemplateInterfaces != null) {
\r
252 nodeTemplateInterfaces.forEach((interfaceKey, nodeTemplateinterface) -> {
\r
253 InterfaceDefinition nodeTypeInterface = nodeTypeInterfaces.get(interfaceKey);
\r
254 logger.trace("Checking Interface Type Content : ({})", TransformationUtils.getJson(nodeTypeInterface));
\r
255 if (nodeTypeInterface != null && nodeTemplateinterface != null) {
\r
256 copyNodeTypeOperation2Template(nodeTypeInterface.getOperations(),
\r
257 nodeTemplateinterface.getOperations());
\r
263 public void copyNodeTypeOperation2Template(Map<String, OperationDefinition> nodeTypeOperations,
\r
264 Map<String, OperationAssignment> nodeTemplateOperations) {
\r
265 if (nodeTypeOperations != null && nodeTemplateOperations != null) {
\r
267 nodeTemplateOperations.forEach((operationKey, nodeTemplateOperation) -> {
\r
268 OperationDefinition nodeTypeInterfaceOperation = nodeTypeOperations.get(operationKey);
\r
269 if (nodeTypeInterfaceOperation != null && nodeTemplateOperation != null) {
\r
270 logger.info("Checking Operation Type Content : " + operationKey + " : "
\r
271 + TransformationUtils.getJson(nodeTypeInterfaceOperation));
\r