2 * ============LICENSE_START=======================================================
4 * ================================================================================
5 * Copyright (C) 2017 AT&T Intellectual Property. All rights reserved.
6 * ================================================================================
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
11 * http://www.apache.org/licenses/LICENSE-2.0
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 * ============LICENSE_END=========================================================
21 package org.openecomp.sdc.translator.services.heattotosca;
23 import org.apache.commons.collections.map.HashedMap;
24 import org.apache.commons.collections4.CollectionUtils;
25 import org.apache.commons.collections4.MapUtils;
26 import org.apache.commons.lang3.StringUtils;
27 import org.apache.commons.lang3.tuple.ImmutablePair;
28 import org.apache.commons.lang3.tuple.Pair;
29 import org.openecomp.config.api.Configuration;
30 import org.openecomp.config.api.ConfigurationManager;
31 import org.openecomp.core.utilities.CommonMethods;
32 import org.openecomp.core.utilities.yaml.YamlUtil;
33 import org.openecomp.sdc.datatypes.configuration.ImplementationConfiguration;
34 import org.openecomp.sdc.heat.services.HeatConstants;
35 import org.openecomp.sdc.logging.api.Logger;
36 import org.openecomp.sdc.logging.api.LoggerFactory;
37 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
38 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
39 import org.openecomp.sdc.tosca.datatypes.ToscaGroupType;
40 import org.openecomp.sdc.tosca.datatypes.ToscaNodeType;
41 import org.openecomp.sdc.tosca.datatypes.ToscaRelationshipType;
42 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
43 import org.openecomp.sdc.tosca.datatypes.model.Constraint;
44 import org.openecomp.sdc.tosca.datatypes.model.EntrySchema;
45 import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
46 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
47 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
48 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
49 import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
50 import org.openecomp.sdc.tosca.datatypes.model.PropertyType;
51 import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate;
52 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
53 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
54 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
55 import org.openecomp.sdc.tosca.datatypes.model.heatextend.PropertyTypeExt;
56 import org.openecomp.sdc.tosca.services.DataModelUtil;
57 import org.openecomp.sdc.tosca.services.ToscaAnalyzerService;
58 import org.openecomp.sdc.tosca.services.ToscaConstants;
59 import org.openecomp.sdc.tosca.services.ToscaUtil;
60 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
61 import org.openecomp.sdc.translator.datatypes.heattotosca.TranslationContext;
62 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionData;
63 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionEntity;
64 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedCompositionMode;
65 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.composition.UnifiedSubstitutionData;
66 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ComputeTemplateConsolidationData;
67 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.ConsolidationData;
68 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.EntityConsolidationData;
69 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FileComputeConsolidationData;
70 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.FilePortConsolidationData;
71 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.GetAttrFuncData;
72 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.NestedTemplateConsolidationData;
73 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.PortTemplateConsolidationData;
74 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.RequirementAssignmentData;
75 import org.openecomp.sdc.translator.datatypes.heattotosca.unifiedmodel.consolidation.TypeComputeConsolidationData;
77 import java.io.ByteArrayInputStream;
78 import java.io.ByteArrayOutputStream;
79 import java.io.IOException;
80 import java.io.NotSerializableException;
81 import java.io.ObjectInputStream;
82 import java.io.ObjectOutputStream;
83 import java.util.ArrayList;
84 import java.util.Collection;
85 import java.util.HashMap;
86 import java.util.HashSet;
87 import java.util.LinkedHashMap;
88 import java.util.List;
90 import java.util.Objects;
91 import java.util.Optional;
93 import java.util.regex.Pattern;
95 import static org.openecomp.sdc.translator.services.heattotosca.Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX;
96 import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX;
97 import static org.openecomp.sdc.translator.services.heattotosca.Constants.COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
98 import static org.openecomp.sdc.translator.services.heattotosca.Constants.PORT_IDENTICAL_VALUE_PROPERTY_PREFIX;
100 public class UnifiedCompositionService {
102 protected static Logger logger =
103 (Logger) LoggerFactory.getLogger(UnifiedCompositionService.class);
104 protected static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
105 private static Map<String, ImplementationConfiguration> unifiedCompositionImplMap;
108 Configuration config = ConfigurationManager.lookup();
109 unifiedCompositionImplMap =
110 config.populateMap(ConfigConstants.MANDATORY_UNIFIED_MODEL_NAMESPACE,
111 ConfigConstants.UNIFIED_COMPOSITION_IMPL_KEY, ImplementationConfiguration.class);
115 private ConsolidationService consolidationService = new ConsolidationService();
117 private static List<EntityConsolidationData> getPortConsolidationDataList(
119 List<UnifiedCompositionData> unifiedCompositionDataList) {
120 List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
121 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
122 for (PortTemplateConsolidationData portTemplateConsolidationData : unifiedCompositionData
123 .getPortTemplateConsolidationDataList()) {
124 if (portIds.contains(portTemplateConsolidationData.getNodeTemplateId())) {
125 portConsolidationDataList.add(portTemplateConsolidationData);
129 return portConsolidationDataList;
133 * Create unified composition.
135 * @param serviceTemplate the service template
136 * @param nestedServiceTemplate the nested service template
137 * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
138 * one entry will be in this list, in case of having
139 * consolidation, all entries in the list are the once which
140 * need to be consolidated.
141 * @param mode the mode
142 * @param context the context
144 public void createUnifiedComposition(ServiceTemplate serviceTemplate,
145 ServiceTemplate nestedServiceTemplate,
146 List<UnifiedCompositionData> unifiedCompositionDataList,
147 UnifiedCompositionMode mode, TranslationContext context) {
148 mdcDataDebugMessage.debugEntryMessage(null, null);
149 Optional<UnifiedComposition> unifiedCompositionInstance = getUnifiedCompositionInstance(mode);
150 if (!unifiedCompositionInstance.isPresent()) {
153 unifiedCompositionInstance.get()
154 .createUnifiedComposition(serviceTemplate, nestedServiceTemplate,
155 unifiedCompositionDataList, context);
156 mdcDataDebugMessage.debugExitMessage(null, null);
160 * Create unified substitution service template according to the input service template, based on
161 * the unified composition data.
163 * @param serviceTemplate the service template
164 * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
165 * one entry will be in this list, in case of having
166 * consolidation, all entries in the list are the once which
167 * need to be consolidated.
168 * @param context the translation context
169 * @return the substitution service template
171 public Optional<ServiceTemplate> createUnifiedSubstitutionServiceTemplate(
172 ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList,
173 TranslationContext context, Integer index) {
174 if (CollectionUtils.isEmpty(unifiedCompositionDataList)) {
175 return Optional.empty();
177 UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
178 String templateName =
179 getTemplateName(serviceTemplate, unifiedCompositionData, index);
180 ServiceTemplate substitutionServiceTemplate =
181 HeatToToscaUtil.createInitSubstitutionServiceTemplate(templateName);
183 createIndexInputParameter(substitutionServiceTemplate);
185 String computeNodeType =
186 handleCompute(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
188 handlePorts(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
189 computeNodeType, context);
190 createOutputParameters(serviceTemplate, substitutionServiceTemplate, unifiedCompositionDataList,
192 NodeType substitutionGlobalNodeType =
193 handleSubstitutionGlobalNodeType(serviceTemplate, substitutionServiceTemplate,
194 context, unifiedCompositionData, index);
196 HeatToToscaUtil.handleSubstitutionMapping(context,
197 getSubstitutionNodeTypeId(serviceTemplate, unifiedCompositionData, index),
198 substitutionServiceTemplate, substitutionGlobalNodeType);
200 context.getTranslatedServiceTemplates().put(templateName, substitutionServiceTemplate);
201 return Optional.of(substitutionServiceTemplate);
205 * Create abstract substitute node template that can be substituted by the input
206 * substitutionServiceTemplate.
208 * @param serviceTemplate the service template
209 * @param substitutionServiceTemplate the subtitution service template
210 * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
211 * one entry will be in this list, in case of having
212 * consolidation, all entries in the list are the once which
213 * need to be consolidated.
214 * @param context the translation context
215 * @return the abstract substitute node template id
217 public String createAbstractSubstituteNodeTemplate(
218 ServiceTemplate serviceTemplate,
219 ServiceTemplate substitutionServiceTemplate,
220 List<UnifiedCompositionData> unifiedCompositionDataList,
221 TranslationContext context,
224 NodeTemplate substitutionNodeTemplate = new NodeTemplate();
225 List<String> directiveList = new ArrayList<>();
226 directiveList.add(ToscaConstants.NODE_TEMPLATE_DIRECTIVE_SUBSTITUTABLE);
227 substitutionNodeTemplate.setDirectives(directiveList);
228 String substituteNodeTemplateType =
229 getSubstitutionNodeTypeId(serviceTemplate, unifiedCompositionDataList.get(0), index);
230 substitutionNodeTemplate.setType(substituteNodeTemplateType);
231 Optional<Map<String, Object>> abstractSubstitutionProperties =
232 createAbstractSubstitutionProperties(serviceTemplate,
233 substitutionServiceTemplate, unifiedCompositionDataList, context);
234 abstractSubstitutionProperties.ifPresent(substitutionNodeTemplate::setProperties);
236 //Add substitution filtering property
237 String substitutionServiceTemplateName = ToscaUtil.getServiceTemplateFileName(
238 substitutionServiceTemplate);
239 int count = unifiedCompositionDataList.size();
240 addSubstitutionFilteringProperty(substitutionServiceTemplateName, substitutionNodeTemplate,
242 //Add index_value property
243 addIndexValueProperty(substitutionNodeTemplate);
244 String substituteNodeTemplateId =
245 getSubstituteNodeTemplateId(serviceTemplate, unifiedCompositionDataList.get(0), index);
246 //Add node template id and related abstract node template id in context
247 addUnifiedSubstitionData(context, serviceTemplate, unifiedCompositionDataList,
248 substituteNodeTemplateId);
250 .addNodeTemplate(serviceTemplate, substituteNodeTemplateId, substitutionNodeTemplate);
251 return substituteNodeTemplateId;
256 * Update the connectivity from/to the "moved" nodes from the original service template to the new
257 * substitution service template.
259 * @param serviceTemplate the service template
260 * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
261 * one entry will be in this list, in case of having
262 * consolidation, all entries in the list are the once which
263 * need to be consolidated.
264 * @param context the translation context
266 public void updateCompositionConnectivity(ServiceTemplate serviceTemplate,
267 List<UnifiedCompositionData> unifiedCompositionDataList,
268 TranslationContext context) {
269 updOutputParamGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
270 updNodesGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
271 updNodesConnectedOutConnectivity(serviceTemplate, unifiedCompositionDataList, context);
272 updNodesConnectedInConnectivity(serviceTemplate, unifiedCompositionDataList, context);
273 updVolumeConnectivity(serviceTemplate, unifiedCompositionDataList, context);
274 updGroupsConnectivity(serviceTemplate, unifiedCompositionDataList, context);
278 * Delete the "moved" nodes from the original service template to the new substitution service
281 * @param serviceTemplate the service template
282 * @param unifiedCompositionDataList the unified composition data list. In case no consolidation,
283 * one entry will be in this list, in case of having
284 * consolidation, all entries in the list are the once which
285 * need to be consolidated.
286 * @param context the translation context
288 public void cleanUnifiedCompositionEntities(
289 ServiceTemplate serviceTemplate,
290 List<UnifiedCompositionData> unifiedCompositionDataList,
291 TranslationContext context) {
292 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
293 ComputeTemplateConsolidationData computeTemplateConsolidationData =
294 unifiedCompositionData.getComputeTemplateConsolidationData();
295 cleanServiceTemplate(serviceTemplate, computeTemplateConsolidationData, context);
297 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
298 getPortTemplateConsolidationDataList(unifiedCompositionData);
299 for (PortTemplateConsolidationData portTemplateConsolidationData :
300 portTemplateConsolidationDataList) {
301 cleanServiceTemplate(serviceTemplate, portTemplateConsolidationData, context);
307 public void cleanNodeTypes(ServiceTemplate serviceTemplate,
308 List<UnifiedCompositionData> unifiedCompositionDataList,
309 TranslationContext context) {
310 for (UnifiedCompositionData unifiedData : unifiedCompositionDataList) {
311 removeCleanedNodeType(
312 unifiedData.getComputeTemplateConsolidationData().getNodeTemplateId(), serviceTemplate,
316 if (MapUtils.isEmpty(serviceTemplate.getNode_types())) {
317 serviceTemplate.setNode_types(null);
322 * Update unified abstract nodes connectivity.
324 * @param serviceTemplate the service template
325 * @param context the context
327 public void updateUnifiedAbstractNodesConnectivity(ServiceTemplate serviceTemplate,
328 TranslationContext context) {
331 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
332 UnifiedSubstitutionData unifiedSubstitutionData = context.getUnifiedSubstitutionData()
333 .get(serviceTemplateFileName);
335 if (Objects.nonNull(unifiedSubstitutionData)) {
336 //Handle get attribute in connectivity for abstarct node to abstract node templates
337 Set<String> abstractNodeIds =
338 new HashSet<>(unifiedSubstitutionData.getAllRelatedAbstractNodeIds());
339 handleGetAttrInConnectivity(serviceTemplate, abstractNodeIds, context);
340 //Handle get attribute in connectivity for abstract node templates to nested node template
341 Set<String> nestedNodeIds =
342 new HashSet<>(unifiedSubstitutionData.getAllUnifiedNestedNodeTemplateIds());
343 handleGetAttrInConnectivity(serviceTemplate, nestedNodeIds, context);
347 public void handleUnifiedNestedDefinition(ServiceTemplate mainServiceTemplate,
348 ServiceTemplate nestedServiceTemplate,
349 List<UnifiedCompositionData> unifiedCompositionDataList,
350 TranslationContext context) {
351 handleUnifiedNestedNodeType(mainServiceTemplate, nestedServiceTemplate, context);
352 updateUnifiedNestedTemplates(mainServiceTemplate, nestedServiceTemplate,
353 unifiedCompositionDataList, context);
356 private void handleGetAttrInConnectivity(ServiceTemplate serviceTemplate,
357 Set<String> unifiedNodeIds,
358 TranslationContext context) {
359 Map<String, NodeTemplate> nodeTemplates =
360 serviceTemplate.getTopology_template().getNode_templates();
361 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
362 for (String unifiedNodeId : unifiedNodeIds) {
363 NodeTemplate nodeTemplate = nodeTemplates.get(unifiedNodeId);
364 handleGetAttrInAbstractNodeTemplate(serviceTemplate, context, serviceTemplateFileName,
369 private void handleUnifiedNestedNodeType(ServiceTemplate mainServiceTemplate,
370 ServiceTemplate nestedServiceTemplate,
371 TranslationContext context) {
374 SubstitutionMapping substitutionMappings =
375 nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
376 String nodeTypeId = substitutionMappings.getNode_type();
378 Optional<String> newNestedNodeTypeId =
379 getNewNestedNodeTypeId(mainServiceTemplate, nestedServiceTemplate, context);
381 if (isNestedServiceTemplateWasHandled(mainServiceTemplate, nestedServiceTemplate, context,
382 newNestedNodeTypeId)) {
383 context.updateHandledComputeType(
384 ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
385 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
386 newNestedNodeTypeId.get());
390 ServiceTemplate globalSubstitutionServiceTemplate =
391 context.getGlobalSubstitutionServiceTemplate();
393 newNestedNodeTypeId.ifPresent(
394 newNestedNodeTypeIdVal -> handleNestedNodeType(nodeTypeId, newNestedNodeTypeIdVal,
395 nestedServiceTemplate, mainServiceTemplate, globalSubstitutionServiceTemplate,
400 private boolean isNestedServiceTemplateWasHandled(ServiceTemplate mainServiceTemplate,
401 ServiceTemplate nestedServiceTemplate,
402 TranslationContext context,
403 Optional<String> newNestedNodeTypeId) {
404 return newNestedNodeTypeId.isPresent()
405 && context.isNestedServiceTemplateWasHandled(
406 ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
407 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
410 private void handleNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
411 ServiceTemplate nestedServiceTemplate,
412 ServiceTemplate mainServiceTemplate,
413 ServiceTemplate globalSubstitutionServiceTemplate,
414 TranslationContext context) {
415 updateNestedServiceTemplate(nestedServiceTemplate, context);
416 updateNestedNodeType(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
418 globalSubstitutionServiceTemplate, context);
423 private void updateNestedServiceTemplate(ServiceTemplate nestedServiceTemplate,
424 TranslationContext context) {
425 enrichPortProperties(nestedServiceTemplate, context);
428 private void enrichPortProperties(ServiceTemplate nestedServiceTemplate,
429 TranslationContext context) {
430 String nestedServiceTemplateFileName =
431 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate);
432 FilePortConsolidationData filePortConsolidationData =
433 context.getConsolidationData().getPortConsolidationData().getFilePortConsolidationData
434 (nestedServiceTemplateFileName);
436 if (Objects.nonNull(filePortConsolidationData)) {
437 Set<String> portNodeTemplateIds = filePortConsolidationData.getAllPortNodeTemplateIds();
438 if (Objects.nonNull(portNodeTemplateIds)) {
439 for (String portNodeTemplateId : portNodeTemplateIds) {
440 NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(nestedServiceTemplate,
442 List<EntityConsolidationData> portEntityConsolidationDataList = new ArrayList<>();
443 portEntityConsolidationDataList.add(filePortConsolidationData
444 .getPortTemplateConsolidationData(portNodeTemplateId));
446 handleNodeTypeProperties(nestedServiceTemplate,
447 portEntityConsolidationDataList, portNodeTemplate, UnifiedCompositionEntity.Port,
454 private void updateNestedNodeType(String nodeTypeId, String newNestedNodeTypeId,
455 ServiceTemplate nestedServiceTemplate,
456 ServiceTemplate mainServiceTemplate,
457 ServiceTemplate globalSubstitutionServiceTemplate,
458 TranslationContext context) {
459 String indexedNewNestedNodeTypeId =
460 updateNodeTypeId(nodeTypeId, newNestedNodeTypeId, nestedServiceTemplate,
462 globalSubstitutionServiceTemplate, context);
464 updateNodeTypeProperties(nestedServiceTemplate, globalSubstitutionServiceTemplate,
465 indexedNewNestedNodeTypeId);
468 private void updateNodeTypeProperties(ServiceTemplate nestedServiceTemplate,
469 ServiceTemplate globalSubstitutionServiceTemplate,
471 ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
472 Map<String, PropertyDefinition> nodeTypePropertiesDefinition =
473 toscaAnalyzerService.manageSubstitutionNodeTypeProperties(nestedServiceTemplate);
474 NodeType nestedNodeType =
475 DataModelUtil.getNodeType(globalSubstitutionServiceTemplate, nodeTypeId);
476 nestedNodeType.setProperties(nodeTypePropertiesDefinition);
479 private String updateNodeTypeId(String nodeTypeId, String newNestedNodeTypeId,
480 ServiceTemplate nestedServiceTemplate,
481 ServiceTemplate mainServiceTemplate,
482 ServiceTemplate globalSubstitutionServiceTemplate,
483 TranslationContext context) {
484 context.addNestedFileToUsedNestedComputeType(
485 ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
486 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
487 newNestedNodeTypeId);
488 String indexedNewNestedNodeTypeId =
489 handleNestedNodeTypeInGlobalSubstitutionTemplate(nodeTypeId, newNestedNodeTypeId,
490 mainServiceTemplate, globalSubstitutionServiceTemplate, context);
492 handleSubstitutionMappingInNestedServiceTemplate(indexedNewNestedNodeTypeId,
493 nestedServiceTemplate);
496 .updateHandledComputeType(
497 ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
498 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate),
499 newNestedNodeTypeId);
500 return indexedNewNestedNodeTypeId;
503 private String handleNestedNodeTypeInGlobalSubstitutionTemplate(String nodeTypeId,
504 String newNestedNodeTypeId,
505 ServiceTemplate mainServiceTemplate,
506 ServiceTemplate globalSubstitutionServiceTemplate,
507 TranslationContext context) {
508 String indexedNodeType =
509 getIndexedGlobalNodeTypeId(newNestedNodeTypeId, mainServiceTemplate, context);
510 handleNestedNodeTypesInGlobalSubstituteServiceTemplate(nodeTypeId, indexedNodeType,
511 globalSubstitutionServiceTemplate, context);
512 return indexedNodeType;
515 private String getIndexedGlobalNodeTypeId(String newNestedNodeTypeId,
516 ServiceTemplate mainServiceTemplate,
517 TranslationContext context) {
518 int globalNodeTypeIndex =
519 context.getGlobalNodeTypeIndex(ToscaUtil.getServiceTemplateFileName(mainServiceTemplate),
520 newNestedNodeTypeId);
521 return globalNodeTypeIndex > 0 ?
522 newNestedNodeTypeId + "_" + String.valueOf(globalNodeTypeIndex) : newNestedNodeTypeId;
525 private void updateUnifiedNestedTemplates(ServiceTemplate mainServiceTemplate,
526 ServiceTemplate nestedServiceTemplate,
527 List<UnifiedCompositionData> unifiedCompositionDataList,
528 TranslationContext context) {
530 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
531 NestedTemplateConsolidationData nestedTemplateConsolidationData =
532 unifiedCompositionData.getNestedTemplateConsolidationData();
533 if (Objects.isNull(nestedTemplateConsolidationData)) {
536 handleNestedNodeTemplateInMainServiceTemplate(
537 nestedTemplateConsolidationData.getNodeTemplateId(), mainServiceTemplate,
538 nestedServiceTemplate, context);
543 * Update connectivity for unified nested patterns.
545 * @param serviceTemplate the service template
546 * @param nestedServiceTemplate the nested service template
547 * @param unifiedCompositionDataList the unified composition data list
548 * @param context the context
550 public void updateUnifiedNestedConnectivity(ServiceTemplate serviceTemplate,
551 ServiceTemplate nestedServiceTemplate,
552 List<UnifiedCompositionData>
553 unifiedCompositionDataList,
554 TranslationContext context) {
556 updNestedCompositionNodesConnectedInConnectivity(serviceTemplate, unifiedCompositionDataList,
558 updNestedCompositionNodesGetAttrInConnectivity(serviceTemplate, unifiedCompositionDataList,
560 updNestedCompositionOutputParamGetAttrInConnectivity(serviceTemplate,
561 unifiedCompositionDataList, context);
566 * Clean unified nested entities. Update the heat stack group with the new node template ids.
568 * @param serviceTemplate the service template
569 * @param unifiedCompositionDataList the unified composition data list
570 * @param context the context
572 public void cleanUnifiedNestedEntities(ServiceTemplate serviceTemplate,
573 List<UnifiedCompositionData> unifiedCompositionDataList,
574 TranslationContext context) {
575 EntityConsolidationData entityConsolidationData = unifiedCompositionDataList.get(0)
576 .getNestedTemplateConsolidationData();
577 updateHeatStackGroupNestedComposition(serviceTemplate, entityConsolidationData, context);
581 protected void updNodesConnectedOutConnectivity(ServiceTemplate serviceTemplate,
582 List<UnifiedCompositionData>
583 unifiedCompositionDataList,
584 TranslationContext context) {
585 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
586 ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
587 .getComputeTemplateConsolidationData();
588 //Add requirements in the abstract node template for nodes connected out for computes
589 String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
590 computeTemplateConsolidationData.getNodeTemplateId());
591 Map<String, List<RequirementAssignmentData>> computeNodesConnectedOut =
592 computeTemplateConsolidationData.getNodesConnectedOut();
593 if (computeNodesConnectedOut != null) {
594 updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
595 newComputeNodeTemplateId, computeNodesConnectedOut, context);
597 String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
598 .getNodeTemplateId());
599 //Add requirements in the abstract node template for nodes connected out for ports
600 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
601 getPortTemplateConsolidationDataList(unifiedCompositionData);
602 for (PortTemplateConsolidationData portTemplateConsolidationData :
603 portTemplateConsolidationDataList) {
604 String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
605 .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
606 Map<String, List<RequirementAssignmentData>> portNodesConnectedOut =
607 portTemplateConsolidationData.getNodesConnectedOut();
608 if (portNodesConnectedOut != null) {
609 updateRequirementInAbstractNodeTemplate(serviceTemplate, portTemplateConsolidationData,
610 newPortNodeTemplateId, portNodesConnectedOut, context);
616 protected void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
617 List<UnifiedCompositionData>
618 unifiedCompositionDataList,
619 TranslationContext context) {
620 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
621 ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
622 .getComputeTemplateConsolidationData();
623 //Update requirements in the node template which pointing to the computes
624 String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
625 computeTemplateConsolidationData.getNodeTemplateId());
626 updNodesConnectedInConnectivity(serviceTemplate, computeTemplateConsolidationData,
627 newComputeNodeTemplateId, context, false);
629 String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
630 .getNodeTemplateId());
631 //Update requirements in the node template which pointing to the ports
632 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
633 getPortTemplateConsolidationDataList(unifiedCompositionData);
634 for (PortTemplateConsolidationData portTemplateConsolidationData :
635 portTemplateConsolidationDataList) {
636 String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
637 .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
638 updNodesConnectedInConnectivity(serviceTemplate, portTemplateConsolidationData,
639 newPortNodeTemplateId, context, false);
644 private void updNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
645 EntityConsolidationData entityConsolidationData,
646 String newNodeTemplateId,
647 TranslationContext context,
649 Map<String, List<RequirementAssignmentData>> nodesConnectedIn =
650 entityConsolidationData.getNodesConnectedIn();
651 if (nodesConnectedIn == null) {
652 //No nodes connected in info
655 for (Map.Entry<String, List<RequirementAssignmentData>> entry : nodesConnectedIn
657 List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
658 for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
659 RequirementAssignment requirementAssignment = requirementAssignmentData
660 .getRequirementAssignment();
661 if (!requirementAssignment.getNode().equals(entityConsolidationData
662 .getNodeTemplateId())) {
663 //The requirement assignment target node should be the one which we are handling in the
664 //consolidation object
667 //Update the requirement assignment object in the original node template
669 updateRequirementForNestedCompositionNodesConnectedIn(serviceTemplate,
670 requirementAssignmentData, entityConsolidationData, newNodeTemplateId, context);
672 updateRequirementForNodesConnectedIn(serviceTemplate, requirementAssignmentData,
673 entityConsolidationData, entry.getKey(), newNodeTemplateId, context);
680 protected void updNestedCompositionNodesConnectedInConnectivity(ServiceTemplate serviceTemplate,
681 List<UnifiedCompositionData>
682 unifiedCompositionDataList,
683 TranslationContext context) {
684 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
685 NestedTemplateConsolidationData nestedTemplateConsolidationData = unifiedCompositionData
686 .getNestedTemplateConsolidationData();
687 //Update requirements in the node template which pointing to the nested nodes
688 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
689 Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
690 serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
691 newNestedNodeTemplateId.ifPresent(
692 newNestedNodeTemplateIdVal -> updNodesConnectedInConnectivity(serviceTemplate,
693 nestedTemplateConsolidationData,
694 newNestedNodeTemplateIdVal, context, true));
698 protected void updVolumeConnectivity(ServiceTemplate serviceTemplate,
699 List<UnifiedCompositionData>
700 unifiedCompositionDataList,
701 TranslationContext context) {
702 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
703 ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
704 .getComputeTemplateConsolidationData();
705 //Add requirements in the abstract node template for compute volumes
706 String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
707 computeTemplateConsolidationData.getNodeTemplateId());
708 Map<String, List<RequirementAssignmentData>> computeVolumes =
709 computeTemplateConsolidationData.getVolumes();
710 if (computeVolumes != null) {
711 updateRequirementInAbstractNodeTemplate(serviceTemplate, computeTemplateConsolidationData,
712 newComputeNodeTemplateId, computeVolumes, context);
717 protected void updGroupsConnectivity(ServiceTemplate serviceTemplate,
718 List<UnifiedCompositionData>
719 unifiedCompositionDataList,
720 TranslationContext context) {
721 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
722 ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
723 .getComputeTemplateConsolidationData();
724 //Add requirements in the abstract node template for nodes connected in for computes
725 String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
726 computeTemplateConsolidationData.getNodeTemplateId());
727 updGroupsConnectivity(serviceTemplate, computeTemplateConsolidationData, context);
729 String computeType = getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData
730 .getNodeTemplateId());
731 //Add requirements in the abstract node template for nodes connected in for ports
732 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
733 getPortTemplateConsolidationDataList(unifiedCompositionData);
734 for (PortTemplateConsolidationData portTemplateConsolidationData :
735 portTemplateConsolidationDataList) {
736 String newPortNodeTemplateId = getNewPortNodeTemplateId(portTemplateConsolidationData
737 .getNodeTemplateId(), computeType, computeTemplateConsolidationData);
738 updGroupsConnectivity(serviceTemplate, portTemplateConsolidationData, context);
743 private void updGroupsConnectivity(ServiceTemplate serviceTemplate, EntityConsolidationData
744 entityConsolidationData, TranslationContext context) {
745 List<String> groupIds = entityConsolidationData.getGroupIds();
746 if (groupIds == null) {
749 String oldNodeTemplateId = entityConsolidationData.getNodeTemplateId();
750 String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
751 serviceTemplate, entityConsolidationData.getNodeTemplateId());
752 Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template().getGroups();
753 if (groups != null) {
754 for (String groupId : groupIds) {
755 GroupDefinition groupDefinition = groups.get(groupId);
756 if (groupDefinition != null) {
757 List<String> groupMembers = groupDefinition.getMembers();
758 if (groupMembers.contains(oldNodeTemplateId)) {
759 //Replace the old node template id
760 groupMembers.remove(oldNodeTemplateId);
761 if (!groupMembers.contains(abstractNodeTemplateId)) {
762 //Add the abstract node template id if not already present
763 groupMembers.add(abstractNodeTemplateId);
771 protected void updOutputParamGetAttrInConnectivity(
772 ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
773 TranslationContext context) {
774 for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
775 ComputeTemplateConsolidationData computeTemplateConsolidationData =
776 unifiedCompositionData.getComputeTemplateConsolidationData();
777 String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
778 computeTemplateConsolidationData.getNodeTemplateId());
780 updOutputParamGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
781 computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId,
785 getComputeTypeSuffix(serviceTemplate,
786 computeTemplateConsolidationData.getNodeTemplateId());
787 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
788 getPortTemplateConsolidationDataList(unifiedCompositionData);
789 for (PortTemplateConsolidationData portTemplateConsolidationData :
790 portTemplateConsolidationDataList) {
791 String newPortNodeTemplateId =
792 getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
793 computeTemplateConsolidationData);
795 updOutputParamGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
796 portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId, context,
802 protected void updNodesGetAttrInConnectivity(
803 ServiceTemplate serviceTemplate,
804 List<UnifiedCompositionData> unifiedComposotionDataList,
805 TranslationContext context) {
806 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
807 getAllConsolidationNodeTemplateIdAndType(unifiedComposotionDataList);
808 for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
809 ComputeTemplateConsolidationData computeTemplateConsolidationData =
810 unifiedCompositionData.getComputeTemplateConsolidationData();
811 String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
812 computeTemplateConsolidationData.getNodeTemplateId());
814 updNodeGetAttrInConnectivity(serviceTemplate, computeTemplateConsolidationData,
815 computeTemplateConsolidationData.getNodeTemplateId(),
816 newComputeNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
819 getComputeTypeSuffix(serviceTemplate,
820 computeTemplateConsolidationData.getNodeTemplateId());
822 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
823 getPortTemplateConsolidationDataList(unifiedCompositionData);
824 for (PortTemplateConsolidationData portTemplateConsolidationData :
825 portTemplateConsolidationDataList) {
826 String newPotNodeTemplateId =
827 getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(), computeType,
828 computeTemplateConsolidationData);
830 updNodeGetAttrInConnectivity(serviceTemplate, portTemplateConsolidationData,
831 portTemplateConsolidationData.getNodeTemplateId(),
832 newPotNodeTemplateId, context, consolidationNodeTemplateIdAndType, false);
837 protected void updNestedCompositionOutputParamGetAttrInConnectivity(
838 ServiceTemplate serviceTemplate, List<UnifiedCompositionData> unifiedComposotionDataList,
839 TranslationContext context) {
840 for (UnifiedCompositionData unifiedCompositionData : unifiedComposotionDataList) {
841 NestedTemplateConsolidationData nestedTemplateConsolidationData =
842 unifiedCompositionData.getNestedTemplateConsolidationData();
843 if (Objects.isNull(nestedTemplateConsolidationData)) {
846 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
847 Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
848 serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
850 newNestedNodeTemplateId.ifPresent(
851 newNestedNodeTemplateIdVal -> updOutputParamGetAttrInConnectivity(serviceTemplate,
852 nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
853 newNestedNodeTemplateIdVal, context, true));
857 protected void updNestedCompositionNodesGetAttrInConnectivity(
858 ServiceTemplate serviceTemplate,
859 List<UnifiedCompositionData> unifiedCompositionDataList,
860 TranslationContext context) {
861 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
862 NestedTemplateConsolidationData nestedTemplateConsolidationData =
863 unifiedCompositionData.getNestedTemplateConsolidationData();
864 if (Objects.isNull(nestedTemplateConsolidationData)) {
867 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
868 Optional<String> newNestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(
869 serviceTemplateFileName, nestedTemplateConsolidationData.getNodeTemplateId());
871 newNestedNodeTemplateId.ifPresent(
872 newNestedNodeTemplateIdVal -> updNodeGetAttrInConnectivity(serviceTemplate,
873 nestedTemplateConsolidationData, nestedTemplateConsolidationData.getNodeTemplateId(),
874 newNestedNodeTemplateIdVal, context, null, true));
878 private void updateRequirementForNodesConnectedIn(
879 ServiceTemplate serviceTemplate,
880 RequirementAssignmentData requirementAssignmentData,
881 EntityConsolidationData entityConsolidationData,
882 String originalNodeTemplateId,
883 String newNodeTemplateId,
884 TranslationContext context) {
885 ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
886 RequirementAssignment requirementAssignment = requirementAssignmentData
887 .getRequirementAssignment();
888 String newAbstractUnifiedNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
889 serviceTemplate, entityConsolidationData.getNodeTemplateId());
890 NodeTemplate abstractUnifiedNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
891 newAbstractUnifiedNodeTemplateId);
892 Optional<String> newCapabilityId = getNewCapabilityForNodesConnectedIn(serviceTemplate,
893 abstractUnifiedNodeTemplate, requirementAssignment, newNodeTemplateId, context);
894 if (newCapabilityId.isPresent()) {
895 //Creating a copy of the requirement object and checking if it already exists in the
896 // original node template
897 RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
898 requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
899 NodeTemplate originalNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
900 originalNodeTemplateId);
901 requirementAssignmentCopy.setCapability(newCapabilityId.get());
902 requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
903 if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(originalNodeTemplate,
904 requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
905 //Update the existing requirement
906 requirementAssignmentData.getRequirementAssignment().setCapability(newCapabilityId
908 requirementAssignmentData.getRequirementAssignment()
909 .setNode(newAbstractUnifiedNodeTemplateId);
911 //The updated requirement already exists in the node template so simply remove the
913 DataModelUtil.removeRequirementAssignment(originalNodeTemplate, requirementAssignmentData
914 .getRequirementId(), requirementAssignmentData.getRequirementAssignment());
919 private void updateRequirementForNestedCompositionNodesConnectedIn(
920 ServiceTemplate serviceTemplate,
921 RequirementAssignmentData requirementAssignmentData,
922 EntityConsolidationData entityConsolidationData,
923 String newNodeTemplateId,
924 TranslationContext context) {
925 ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
926 String newAbstractUnifiedNodeTemplateId = newNodeTemplateId;
927 RequirementAssignment requirementAssignment = requirementAssignmentData
928 .getRequirementAssignment();
929 //Creating a copy of the requirement object and checking if it already exists in the
930 // original node template
931 RequirementAssignment requirementAssignmentCopy = (RequirementAssignment) getClonedObject(
932 requirementAssignmentData.getRequirementAssignment(), RequirementAssignment.class);
933 NodeTemplate unifiedAbstractNestedNodeTemplate = DataModelUtil
934 .getNodeTemplate(serviceTemplate, newAbstractUnifiedNodeTemplateId);
935 requirementAssignmentCopy.setCapability(requirementAssignment.getCapability());
936 requirementAssignmentCopy.setNode(newAbstractUnifiedNodeTemplateId);
937 if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(unifiedAbstractNestedNodeTemplate,
938 requirementAssignmentData.getRequirementId(), requirementAssignmentCopy)) {
939 //Update the existing requirement
940 requirementAssignmentData.getRequirementAssignment()
941 .setNode(newAbstractUnifiedNodeTemplateId);
943 //The updated requirement already exists in the node template so simply remove the
945 DataModelUtil.removeRequirementAssignment(unifiedAbstractNestedNodeTemplate,
946 requirementAssignmentData.getRequirementId(), requirementAssignmentData
947 .getRequirementAssignment());
951 private Optional<String> getNewCapabilityForNodesConnectedIn(ServiceTemplate serviceTemplate,
952 NodeTemplate unifiedNodeTemplate,
953 RequirementAssignment
954 requirementAssignment,
955 String newNodeTemplateId,
956 TranslationContext context) {
957 ServiceTemplate globalSubstitutionServiceTemplate =
958 HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
959 Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
960 String unifiedNodeTemplateType = unifiedNodeTemplate.getType();
961 NodeType unifiedNodeType = nodeTypes.get(unifiedNodeTemplateType);
962 Map<String, CapabilityDefinition> abstractNodeTypeCapabilities = unifiedNodeType
964 for (Map.Entry<String, CapabilityDefinition> entry : abstractNodeTypeCapabilities.entrySet()) {
965 String capabilityId = entry.getKey();
966 CapabilityDefinition capabilityDefinition = entry.getValue();
967 String capabilityType = capabilityDefinition.getType();
968 if (capabilityType.equals(requirementAssignment.getCapability())) {
969 //Matching capability type found..Check if the id ends with new node template id
970 if (capabilityId.endsWith(newNodeTemplateId)) {
971 return Optional.ofNullable(capabilityId);
975 return Optional.empty();
979 private void updateRequirementInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
980 EntityConsolidationData
981 entityConsolidationData,
982 String newNodeTemplateId,
983 Map<String, List<RequirementAssignmentData>>
984 requirementAssignmentDataMap,
985 TranslationContext context) {
986 ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
987 for (Map.Entry<String, List<RequirementAssignmentData>> entry : requirementAssignmentDataMap
989 String abstractNodeTemplateId = context.getUnifiedAbstractNodeTemplateId(
990 serviceTemplate, entityConsolidationData.getNodeTemplateId());
991 NodeTemplate abstractNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
992 abstractNodeTemplateId);
993 if (abstractNodeTemplate == null) {
994 //The abstract node template is not found from id in the context
997 List<RequirementAssignmentData> requirementAssignmentDataList = entry.getValue();
998 for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
999 String oldRequirementId = requirementAssignmentData.getRequirementId();
1000 RequirementAssignment abstractRequirementAssignment = (RequirementAssignment)
1001 getClonedObject(requirementAssignmentData.getRequirementAssignment(),
1002 RequirementAssignment.class);
1003 String newRequirementId = oldRequirementId + "_" + newNodeTemplateId;
1004 //Check if the requirement is not already present in the list of requirements of the
1005 // abstract node template
1006 if (!toscaAnalyzerService.isRequirementExistInNodeTemplate(abstractNodeTemplate,
1007 newRequirementId, abstractRequirementAssignment)) {
1008 DataModelUtil.addRequirementAssignment(abstractNodeTemplate, newRequirementId,
1009 abstractRequirementAssignment);
1010 //Update the volume relationship template if required
1011 updateVolumeRelationshipTemplate(serviceTemplate, abstractRequirementAssignment
1012 .getRelationship(), context);
1018 private NodeTemplate getAbstractNodeTemplate(
1019 ServiceTemplate serviceTemplate,
1020 UnifiedCompositionEntity unifiedCompositionEntity,
1021 ComputeTemplateConsolidationData computeTemplateConsolidationData,
1022 PortTemplateConsolidationData portTemplateConsolidationData,
1023 TranslationContext context) {
1024 String abstractNodeTemplateId =
1025 getAbstractNodeTemplateId(serviceTemplate, unifiedCompositionEntity,
1026 computeTemplateConsolidationData, portTemplateConsolidationData, context);
1028 return DataModelUtil.getNodeTemplate(serviceTemplate,
1029 abstractNodeTemplateId);
1032 private String getAbstractNodeTemplateId(
1033 ServiceTemplate serviceTemplate,
1034 UnifiedCompositionEntity unifiedCompositionEntity,
1035 ComputeTemplateConsolidationData computeTemplateConsolidationData,
1036 PortTemplateConsolidationData portTemplateConsolidationData,
1037 TranslationContext context) {
1038 switch (unifiedCompositionEntity) {
1040 return context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
1041 computeTemplateConsolidationData.getNodeTemplateId());
1043 return context.getUnifiedAbstractNodeTemplateId(serviceTemplate,
1044 portTemplateConsolidationData.getNodeTemplateId());
1050 private void updNodeGetAttrInConnectivity(
1051 ServiceTemplate serviceTemplate,
1052 EntityConsolidationData entityConsolidationData,
1053 String oldNodeTemplateId, String newNodeTemplateId,
1054 TranslationContext context,
1055 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
1057 Map<String, List<GetAttrFuncData>> nodesGetAttrIn = entityConsolidationData.getNodesGetAttrIn();
1058 if (MapUtils.isEmpty(nodesGetAttrIn)) {
1062 for (String sourceNodeTemplateId : nodesGetAttrIn.keySet()) {
1063 NodeTemplate sourceNodeTemplate =
1064 DataModelUtil.getNodeTemplate(serviceTemplate, sourceNodeTemplateId);
1065 if (!isNested && consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
1068 List<GetAttrFuncData> getAttrFuncDataList = nodesGetAttrIn.get(sourceNodeTemplateId);
1069 for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
1070 Object propertyValue =
1071 DataModelUtil.getPropertyValue(sourceNodeTemplate, getAttrFuncData.getFieldName());
1072 String newAttrName = null;
1073 String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
1075 newGetAttrAbstractNodeTemplateId =
1076 context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
1077 newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
1078 .getAttributeName());
1080 List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(propertyValue);
1081 updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
1082 newAttrName, getAttrFuncValueList, isNested);
1087 private void updateGetAttrValue(String oldNodeTemplateId, GetAttrFuncData getAttrFuncData,
1088 String newNodeTemplateId, String newAttrName,
1089 List<List<Object>> getAttrFuncValueList, boolean isNested) {
1090 for (List<Object> getAttrFuncValue : getAttrFuncValueList) {
1091 if (oldNodeTemplateId.equals(getAttrFuncValue.get(0))
1092 && getAttrFuncData.getAttributeName().equals(getAttrFuncValue.get(1))) {
1093 getAttrFuncValue.set(0, newNodeTemplateId);
1095 getAttrFuncValue.set(1, newAttrName);
1101 private String getTemplateName(ServiceTemplate serviceTemplate,
1102 UnifiedCompositionData unifiedCompositionData,
1104 ComputeTemplateConsolidationData computeTemplateConsolidationData =
1105 unifiedCompositionData.getComputeTemplateConsolidationData();
1106 String computeType =
1107 getComputeTypeSuffix(serviceTemplate, computeTemplateConsolidationData.getNodeTemplateId());
1108 String templateName = "Nested_" + computeType;
1109 if (Objects.nonNull(index)) {
1110 templateName = templateName + "_" + index.toString();
1112 return templateName;
1115 private String getComputeTypeSuffix(ServiceTemplate serviceTemplate,
1116 String computeNodeTemplateId) {
1117 NodeTemplate computeNodeTemplate =
1118 DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
1119 return getComputeTypeSuffix(computeNodeTemplate.getType());
1123 * Gets compute type.
1125 * @param computeType the compute node type abc.def.vFSB
1126 * @return the compute type e.g.:vFSB
1128 private String getComputeTypeSuffix(String computeType) {
1129 return DataModelUtil.getNamespaceSuffix(computeType);
1132 private void updOutputParamGetAttrInConnectivity(ServiceTemplate serviceTemplate,
1133 EntityConsolidationData entityConsolidationData,
1134 String oldNodeTemplateId,
1135 String newNodeTemplateId,
1136 TranslationContext context,
1138 List<GetAttrFuncData> outputParametersGetAttrIn =
1139 entityConsolidationData.getOutputParametersGetAttrIn();
1140 if (CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
1143 for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
1144 Object outputParamValue =
1145 DataModelUtil.getOuputParameter(serviceTemplate, getAttrFuncData.getFieldName())
1147 String newAttrName = null;
1148 String newGetAttrAbstractNodeTemplateId = newNodeTemplateId;
1150 newGetAttrAbstractNodeTemplateId =
1151 context.getUnifiedAbstractNodeTemplateId(serviceTemplate, oldNodeTemplateId);
1152 newAttrName = getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData
1153 .getAttributeName());
1155 List<List<Object>> getAttrFuncValueList = extractGetAttrFunction(outputParamValue);
1156 updateGetAttrValue(oldNodeTemplateId, getAttrFuncData, newGetAttrAbstractNodeTemplateId,
1158 getAttrFuncValueList, isNested);
1163 private List<List<Object>> extractGetAttrFunction(Object valueObject) {
1165 List<List<Object>> getAttrValueList = new ArrayList<>();
1167 if (valueObject instanceof Map) {
1168 if (((Map) valueObject).containsKey(ToscaFunctions.GET_ATTRIBUTE.getDisplayName())) {
1169 getAttrValueList.add(
1170 (List<Object>) ((Map) valueObject).get(ToscaFunctions.GET_ATTRIBUTE.getDisplayName()));
1173 for (Object key : ((Map) valueObject).keySet()) {
1174 getAttrValueList.addAll(extractGetAttrFunction(((Map) valueObject).get(key)));
1178 } else if (valueObject instanceof List) {
1179 for (Object valueEntity : (List) valueObject) {
1180 getAttrValueList.addAll(extractGetAttrFunction(valueEntity));
1183 return getAttrValueList;
1186 private boolean isIncludeGetInputFunc(Object valueObject) {
1187 if (valueObject instanceof Map) {
1188 if (((Map) valueObject).containsKey(ToscaFunctions.GET_INPUT.getDisplayName())) {
1191 Map.Entry<String, Object> functionMapEntry =
1192 (Map.Entry<String, Object>) ((Map) valueObject).entrySet().iterator().next();
1193 return isIncludeGetInputFunc(functionMapEntry.getValue());
1195 } else if (valueObject instanceof List) {
1196 for (Object valueEntity : (List) valueObject) {
1197 if (isIncludeGetInputFunc(valueEntity) == true) {
1205 private void createOutputParameters(ServiceTemplate serviceTemplate,
1206 ServiceTemplate substitutionServiceTemplate,
1207 List<UnifiedCompositionData> unifiedCompositionDataList,
1208 String computeNodeType) {
1210 createOutputParametersForCompute(serviceTemplate, substitutionServiceTemplate,
1211 unifiedCompositionDataList);
1212 createOutputParameterForPorts(serviceTemplate, substitutionServiceTemplate,
1213 unifiedCompositionDataList, computeNodeType);
1216 private void createOutputParameterForPorts(
1217 ServiceTemplate serviceTemplate,
1218 ServiceTemplate substitutionServiceTemplate,
1219 List<UnifiedCompositionData> unifiedCompositionDataList,
1220 String connectedComputeNodeType) {
1221 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1222 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1223 getPortTemplateConsolidationDataList(unifiedCompositionData);
1224 if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1228 for (PortTemplateConsolidationData portTemplateConsolidationData :
1229 portTemplateConsolidationDataList) {
1230 String newPortNodeTemplateId =
1231 getNewPortNodeTemplateId(portTemplateConsolidationData.getNodeTemplateId(),
1232 connectedComputeNodeType,
1233 unifiedCompositionData.getComputeTemplateConsolidationData());
1234 addOutputParameters(portTemplateConsolidationData, newPortNodeTemplateId,
1235 substitutionServiceTemplate, unifiedCompositionDataList);
1240 //The ID should be <vm_type>_<port_type> or <vm_type>_<portNodeTemplateId>
1241 private String getNewPortNodeTemplateId(
1242 String portNodeTemplateId,
1243 String connectedComputeNodeType,
1244 ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1246 StringBuilder newPortNodeTemplateId = new StringBuilder();
1247 String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
1248 newPortNodeTemplateId.append(DataModelUtil.getNamespaceSuffix(connectedComputeNodeType));
1249 if (computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
1251 newPortNodeTemplateId.append("_").append(portNodeTemplateId);
1253 //consolidation port
1254 newPortNodeTemplateId.append("_").append(portType);
1256 return newPortNodeTemplateId.toString();
1259 private void createOutputParametersForCompute(
1260 ServiceTemplate serviceTemplate,
1261 ServiceTemplate substitutionServiceTemplate,
1262 List<UnifiedCompositionData>
1263 unifiedCompositionDataList) {
1264 List<EntityConsolidationData> computeConsolidationDataList =
1265 getComputeConsolidationDataList(unifiedCompositionDataList);
1267 for (EntityConsolidationData computeTemplateConsolidationData : computeConsolidationDataList) {
1268 String newComputeNodeTemplateId =
1269 getNewComputeNodeTemplateId(serviceTemplate,
1270 computeTemplateConsolidationData.getNodeTemplateId());
1271 addOutputParameters(computeTemplateConsolidationData, newComputeNodeTemplateId,
1272 substitutionServiceTemplate, unifiedCompositionDataList);
1276 private void addOutputParameters(EntityConsolidationData entityConsolidationData,
1277 String newNodeTemplateId,
1278 ServiceTemplate substitutionServiceTemplate,
1279 List<UnifiedCompositionData> unifiedCompositionDataList) {
1280 handleNodesGetAttrIn(entityConsolidationData, newNodeTemplateId, substitutionServiceTemplate,
1281 unifiedCompositionDataList);
1283 handleOutputParamGetAttrIn(entityConsolidationData, newNodeTemplateId,
1284 substitutionServiceTemplate);
1287 private void handleOutputParamGetAttrIn(EntityConsolidationData entityConsolidationData,
1288 String newNodeTemplateId,
1289 ServiceTemplate substitutionServiceTemplate) {
1290 List<GetAttrFuncData> outputParametersGetAttrIn =
1291 entityConsolidationData.getOutputParametersGetAttrIn();
1292 if (!CollectionUtils.isEmpty(outputParametersGetAttrIn)) {
1293 for (GetAttrFuncData getAttrFuncData : outputParametersGetAttrIn) {
1294 createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId,
1295 substitutionServiceTemplate, getAttrFuncData);
1300 private void handleNodesGetAttrIn(EntityConsolidationData entityConsolidationData,
1301 String newNodeTemplateId,
1302 ServiceTemplate substitutionServiceTemplate,
1303 List<UnifiedCompositionData> unifiedCompositionDataList) {
1304 Map<String, List<GetAttrFuncData>> getAttrIn = entityConsolidationData.getNodesGetAttrIn();
1306 if (!MapUtils.isEmpty(getAttrIn)) {
1307 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
1308 getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
1309 for (String sourceNodeTemplateId : getAttrIn.keySet()) {
1310 if (!consolidationNodeTemplateIdAndType.keySet().contains(sourceNodeTemplateId)) {
1311 List<GetAttrFuncData> getAttrFuncDataList = getAttrIn.get(sourceNodeTemplateId);
1312 for (GetAttrFuncData getAttrFuncData : getAttrFuncDataList) {
1313 createAndAddOutputParameter(entityConsolidationData, newNodeTemplateId,
1314 substitutionServiceTemplate, getAttrFuncData);
1321 private void createAndAddOutputParameter(EntityConsolidationData entityConsolidationData,
1322 String newNodeTemplateId,
1323 ServiceTemplate substitutionServiceTemplate,
1324 GetAttrFuncData getAttrFuncData) {
1325 Map<String, List<Object>> parameterValue = new HashMap<>();
1326 List<Object> valueList = new ArrayList<>();
1327 valueList.add(newNodeTemplateId);
1328 valueList.add(getAttrFuncData.getAttributeName());
1329 parameterValue.put(ToscaFunctions.GET_ATTRIBUTE.getDisplayName(), valueList);
1330 ParameterDefinition outputParameter = new ParameterDefinition();
1331 outputParameter.setValue(parameterValue);
1332 //todo - the type need to be change based on the attribute type in the accordingly node type
1333 // of this node template - XXX, instead of list of string, list of XXXX,
1334 outputParameter.setType(PropertyType.LIST.getDisplayName());
1335 outputParameter.setEntry_schema(
1336 DataModelUtil.createEntrySchema(PropertyType.STRING.getDisplayName(), null, null));
1337 DataModelUtil.addOutputParameterToTopologyTemplate(substitutionServiceTemplate,
1338 getNewSubstitutionOutputParameterId(newNodeTemplateId, getAttrFuncData.getAttributeName()),
1342 private String getNewSubstitutionOutputParameterId(String newNodeTemplateId,
1343 String attributeName) {
1344 return newNodeTemplateId + "_" + attributeName;
1347 private void addUnifiedSubstitionData(TranslationContext context, ServiceTemplate
1348 serviceTemplate, List<UnifiedCompositionData> unifiedCompositionDataList, String
1349 substituteNodeTemplateId) {
1350 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
1351 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1352 //Add compute node template mapping information
1353 ComputeTemplateConsolidationData computeTemplateConsolidationData =
1354 unifiedCompositionData.getComputeTemplateConsolidationData();
1355 String computeNodeTemplateId = computeTemplateConsolidationData.getNodeTemplateId();
1356 context.addUnifiedSubstitutionData(serviceTemplateFileName, computeNodeTemplateId,
1357 substituteNodeTemplateId);
1358 //Add Port template mapping information
1359 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1360 getPortTemplateConsolidationDataList(unifiedCompositionData);
1362 if (CollectionUtils.isNotEmpty(portTemplateConsolidationDataList)) {
1363 for (PortTemplateConsolidationData portTemplateConsolidationData :
1364 portTemplateConsolidationDataList) {
1365 String oldPortNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
1366 context.addUnifiedSubstitutionData(serviceTemplateFileName, oldPortNodeTemplateId,
1367 substituteNodeTemplateId);
1373 private void addSubstitutionFilteringProperty(String templateName, NodeTemplate nodeTemplate,
1375 Map<String, Object> serviceTemplateFilterPropertyValue = new HashMap<>();
1376 Map<String, Object> properties = nodeTemplate.getProperties();
1377 serviceTemplateFilterPropertyValue.put(ToscaConstants
1378 .SUBSTITUTE_SERVICE_TEMPLATE_PROPERTY_NAME, templateName);
1379 serviceTemplateFilterPropertyValue.put(ToscaConstants.COUNT_PROPERTY_NAME, count);
1380 properties.put(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME,
1381 serviceTemplateFilterPropertyValue);
1382 nodeTemplate.setProperties(properties);
1385 private void addIndexValueProperty(NodeTemplate nodeTemplate) {
1386 List<String> indexValueGetPropertyValue = new ArrayList<>();
1387 indexValueGetPropertyValue.add(ToscaConstants.MODELABLE_ENTITY_NAME_SELF);
1388 indexValueGetPropertyValue.add(ToscaConstants.SERVICE_TEMPLATE_FILTER_PROPERTY_NAME);
1389 indexValueGetPropertyValue.add(ToscaConstants.INDEX_VALUE_PROPERTY_NAME);
1391 Map<String, Object> indexPropertyValue = new HashMap<>();
1392 Map<String, Object> properties = nodeTemplate.getProperties();
1393 indexPropertyValue.put(ToscaFunctions.GET_PROPERTY.getDisplayName(),
1394 indexValueGetPropertyValue);
1395 properties.put(ToscaConstants.INDEX_VALUE_PROPERTY_NAME,
1396 indexPropertyValue);
1397 nodeTemplate.setProperties(properties);
1400 private String getSubstituteNodeTemplateId(ServiceTemplate serviceTemplate,
1401 UnifiedCompositionData unifiedCompositionData,
1403 String computeNodeTemplateId =
1404 unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
1405 NodeTemplate computeNodeTemplate =
1406 DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
1407 String nodeTemplateId = ABSTRACT_NODE_TEMPLATE_ID_PREFIX + DataModelUtil
1408 .getNamespaceSuffix(computeNodeTemplate.getType());
1409 if (Objects.nonNull(index)) {
1410 nodeTemplateId = nodeTemplateId + "_" + index.toString();
1412 return nodeTemplateId;
1415 private String getSubstitutionNodeTypeId(ServiceTemplate serviceTemplate,
1416 UnifiedCompositionData unifiedCompositionData,
1418 String computeNodeTemplateId =
1419 unifiedCompositionData.getComputeTemplateConsolidationData().getNodeTemplateId();
1420 NodeTemplate computeNodeTemplate =
1421 DataModelUtil.getNodeTemplate(serviceTemplate, computeNodeTemplateId);
1422 String nodeTypeId = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX
1423 + DataModelUtil.getNamespaceSuffix(computeNodeTemplate.getType());
1424 if (Objects.nonNull(index)) {
1425 nodeTypeId = nodeTypeId + "_" + index.toString();
1430 private String getNewComputeNodeTemplateId(
1431 ServiceTemplate serviceTemplate,
1432 String computeNodeTemplateId) {
1433 return getComputeTypeSuffix(serviceTemplate, computeNodeTemplateId);
1436 private NodeType handleSubstitutionGlobalNodeType(ServiceTemplate serviceTemplate,
1437 ServiceTemplate substitutionServiceTemplate,
1438 TranslationContext context,
1439 UnifiedCompositionData unifiedCompositionData,
1441 String substitutionNodeTypeId =
1442 getSubstitutionNodeTypeId(serviceTemplate, unifiedCompositionData, index);
1443 NodeType substitutionNodeType = new ToscaAnalyzerServiceImpl()
1444 .createInitSubstitutionNodeType(substitutionServiceTemplate,
1445 ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
1446 ServiceTemplate globalSubstitutionServiceTemplate =
1447 HeatToToscaUtil.fetchGlobalSubstitutionServiceTemplate(serviceTemplate, context);
1448 DataModelUtil.addNodeType(globalSubstitutionServiceTemplate, substitutionNodeTypeId,
1449 substitutionNodeType);
1451 return substitutionNodeType;
1454 private void handlePorts(ServiceTemplate serviceTemplate,
1455 ServiceTemplate substitutionServiceTemplate,
1456 List<UnifiedCompositionData> unifiedCompositionDataList,
1457 String connectedComputeNodeType,
1458 TranslationContext context) {
1460 if (unifiedCompositionDataList.size() > 1) {
1461 handleConsolidationPorts(serviceTemplate, substitutionServiceTemplate,
1462 unifiedCompositionDataList, connectedComputeNodeType, context);
1464 handleSinglePorts(serviceTemplate, substitutionServiceTemplate, connectedComputeNodeType,
1465 unifiedCompositionDataList, context);
1469 private void handleSinglePorts(ServiceTemplate serviceTemplate,
1470 ServiceTemplate substitutionServiceTemplate,
1471 String connectedComputeNodeType,
1472 List<UnifiedCompositionData> unifiedCompositionDataList,
1473 TranslationContext context) {
1474 UnifiedCompositionData unifiedCompositionData = unifiedCompositionDataList.get(0);
1475 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
1476 getPortTemplateConsolidationDataList(unifiedCompositionData);
1477 if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1480 for (PortTemplateConsolidationData portTemplateConsolidationData :
1481 portTemplateConsolidationDataList) {
1482 List<EntityConsolidationData> portConsolidationDataList = new ArrayList<>();
1483 portConsolidationDataList.add(portTemplateConsolidationData);
1484 handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1485 portConsolidationDataList, connectedComputeNodeType,
1486 unifiedCompositionData.getComputeTemplateConsolidationData(),
1487 unifiedCompositionDataList, context);
1491 private void handleConsolidationPorts(ServiceTemplate serviceTemplate,
1492 ServiceTemplate substitutionServiceTemplate,
1493 List<UnifiedCompositionData> unifiedCompositionDataList,
1494 String connectedComputeNodeType,
1495 TranslationContext context) {
1496 Collection<ComputeTemplateConsolidationData> computeConsolidationDataList =
1497 (Collection) getComputeConsolidationDataList(unifiedCompositionDataList);
1499 Map<String, Set<String>> portIdsPerPortType = UnifiedCompositionUtil
1500 .collectAllPortsFromEachTypesFromComputes(computeConsolidationDataList);
1502 for (String portType : portIdsPerPortType.keySet()) {
1503 List<EntityConsolidationData> portTemplateConsolidationDataList =
1504 getPortConsolidationDataList(portIdsPerPortType.get(portType),
1505 unifiedCompositionDataList);
1506 if (CollectionUtils.isEmpty(portTemplateConsolidationDataList)) {
1510 handlePortNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1511 portTemplateConsolidationDataList, connectedComputeNodeType,
1512 unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData(),
1513 unifiedCompositionDataList, context);
1517 private void handlePortNodeTemplate(
1518 ServiceTemplate serviceTemplate,
1519 ServiceTemplate substitutionServiceTemplate,
1520 List<EntityConsolidationData> portTemplateConsolidationDataList,
1521 String connectedComputeNodeType,
1522 ComputeTemplateConsolidationData computeTemplateConsolidationData,
1523 List<UnifiedCompositionData> unifiedCompositionDataList,
1524 TranslationContext context) {
1525 EntityConsolidationData portTemplateConsolidationData =
1526 portTemplateConsolidationDataList.get(0);
1527 NodeTemplate newPortNodeTemplate = getNodeTemplate(
1528 portTemplateConsolidationData.getNodeTemplateId(), serviceTemplate, context).clone();
1530 removeConnectivityOut(portTemplateConsolidationData, newPortNodeTemplate);
1531 handleProperties(serviceTemplate, newPortNodeTemplate,
1532 substitutionServiceTemplate, UnifiedCompositionEntity.Port,
1533 portTemplateConsolidationDataList, computeTemplateConsolidationData,
1534 unifiedCompositionDataList, context);
1536 String newPortNodeTemplateId =
1537 getNewPortNodeTemplateId(portTemplateConsolidationData
1538 .getNodeTemplateId(), connectedComputeNodeType,
1539 computeTemplateConsolidationData);
1540 //Update requirements for relationships between the consolidation entities
1541 handleConsolidationEntitiesRequirementConnectivity(newPortNodeTemplateId, newPortNodeTemplate,
1542 substitutionServiceTemplate, context);
1543 DataModelUtil.addNodeTemplate(substitutionServiceTemplate, newPortNodeTemplateId,
1544 newPortNodeTemplate);
1546 //Add the node template mapping in the context for handling requirement updation
1547 context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
1548 .getServiceTemplateFileName(substitutionServiceTemplate),
1549 portTemplateConsolidationData.getNodeTemplateId(), newPortNodeTemplateId);
1553 private NodeTemplate getNodeTemplate(String nodeTemplateId, ServiceTemplate serviceTemplate,
1554 TranslationContext context) {
1556 NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate, nodeTemplateId);
1558 if (Objects.isNull(nodeTemplate)) {
1559 nodeTemplate = context
1560 .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
1564 return nodeTemplate;
1568 private String handleCompute(ServiceTemplate serviceTemplate,
1569 ServiceTemplate substitutionServiceTemplate,
1570 List<UnifiedCompositionData> unifiedCompositionDataList,
1571 TranslationContext context) {
1572 ComputeTemplateConsolidationData computeTemplateConsolidationData =
1573 unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
1574 handleComputeNodeTemplate(serviceTemplate, substitutionServiceTemplate,
1575 unifiedCompositionDataList, context);
1576 return handleComputeNodeType(serviceTemplate, substitutionServiceTemplate,
1577 computeTemplateConsolidationData);
1580 private String handleComputeNodeType(
1581 ServiceTemplate serviceTemplate,
1582 ServiceTemplate substitutionServiceTemplate,
1583 ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1584 NodeTemplate computeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1585 computeTemplateConsolidationData.getNodeTemplateId());
1586 NodeType computeNodeType =
1587 DataModelUtil.getNodeType(serviceTemplate, computeNodeTemplate.getType());
1589 .addNodeType(substitutionServiceTemplate, computeNodeTemplate.getType(), computeNodeType);
1591 return computeNodeTemplate.getType();
1594 private void handleComputeNodeTemplate(ServiceTemplate serviceTemplate,
1595 ServiceTemplate substitutionServiceTemplate,
1596 List<UnifiedCompositionData> unifiedCompositionDataList,
1597 TranslationContext context) {
1598 ComputeTemplateConsolidationData computeTemplateConsolidationData =
1599 unifiedCompositionDataList.get(0).getComputeTemplateConsolidationData();
1600 NodeTemplate newComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
1601 computeTemplateConsolidationData.getNodeTemplateId()).clone();
1603 removeConnectivityOut(computeTemplateConsolidationData, newComputeNodeTemplate);
1604 removeVolumeConnectivity(computeTemplateConsolidationData, newComputeNodeTemplate);
1606 List<EntityConsolidationData> computeConsoliadtionDataList =
1607 getComputeConsolidationDataList(unifiedCompositionDataList);
1609 handleProperties(serviceTemplate, newComputeNodeTemplate,
1610 substitutionServiceTemplate, UnifiedCompositionEntity.Compute,
1611 computeConsoliadtionDataList, computeTemplateConsolidationData, unifiedCompositionDataList,
1614 String newComputeNodeTemplateId = getNewComputeNodeTemplateId(serviceTemplate,
1615 computeTemplateConsolidationData.getNodeTemplateId());
1616 //Update requirements for relationships between the consolidation entities
1617 handleConsolidationEntitiesRequirementConnectivity(newComputeNodeTemplateId,
1618 newComputeNodeTemplate,
1619 substitutionServiceTemplate, context);
1621 .addNodeTemplate(substitutionServiceTemplate,
1622 newComputeNodeTemplateId, newComputeNodeTemplate);
1623 //Add the node template mapping in the context for handling requirement updation
1624 context.addSubstitutionServiceTemplateUnifiedSubstitutionData(ToscaUtil
1625 .getServiceTemplateFileName(substitutionServiceTemplate),
1626 computeTemplateConsolidationData.getNodeTemplateId(), newComputeNodeTemplateId);
1630 private List<EntityConsolidationData> getComputeConsolidationDataList(
1631 List<UnifiedCompositionData> unifiedCompositionDataList) {
1632 List<EntityConsolidationData> computeConsolidationDataList = new ArrayList<>();
1633 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
1634 computeConsolidationDataList
1635 .add(unifiedCompositionData.getComputeTemplateConsolidationData());
1637 return computeConsolidationDataList;
1641 private void handleProperties(ServiceTemplate serviceTemplate,
1642 NodeTemplate nodeTemplate,
1643 ServiceTemplate substitutionServiceTemplate,
1644 UnifiedCompositionEntity unifiedCompositionEntity,
1645 List<EntityConsolidationData> entityConsolidationDataList,
1646 ComputeTemplateConsolidationData computeTemplateConsolidationData,
1647 List<UnifiedCompositionData> unifiedCompositionDataList,
1648 TranslationContext context) {
1650 nodeTemplate.setProperties(new HashedMap());
1651 handleNodeTemplateProperties(serviceTemplate, nodeTemplate, substitutionServiceTemplate,
1652 unifiedCompositionEntity, entityConsolidationDataList, computeTemplateConsolidationData,
1653 unifiedCompositionDataList, context);
1654 //Add enrich properties from openecomp node type as input to global and substitution ST
1655 handleNodeTypeProperties(substitutionServiceTemplate,
1656 entityConsolidationDataList, nodeTemplate, unifiedCompositionEntity,
1657 computeTemplateConsolidationData, context);
1661 private void handleNodeTemplateProperties(ServiceTemplate serviceTemplate,
1662 NodeTemplate nodeTemplate,
1663 ServiceTemplate substitutionServiceTemplate,
1664 UnifiedCompositionEntity unifiedCompositionEntity,
1665 List<EntityConsolidationData>
1666 entityConsolidationDataList,
1667 ComputeTemplateConsolidationData
1668 computeTemplateConsolidationData,
1669 List<UnifiedCompositionData> unifiedCompositionDataList,
1670 TranslationContext context) {
1671 List<String> propertiesWithIdenticalVal =
1672 consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context);
1674 for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
1675 String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
1676 Map<String, Object> properties =
1677 DataModelUtil.getNodeTemplateProperties(serviceTemplate, nodeTemplateId);
1678 if (MapUtils.isEmpty(properties)) {
1682 for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
1683 NodeType nodeTypeWithFlatHierarchy =
1684 HeatToToscaUtil.getNodeTypeWithFlatHierarchy(nodeTemplate.getType(), serviceTemplate,
1686 PropertyDefinition propertyDefinition =
1687 nodeTypeWithFlatHierarchy.getProperties().get(propertyEntry.getKey());
1688 String propertyType = propertyDefinition.getType();
1690 if (propertiesWithIdenticalVal.contains(propertyEntry.getKey())) {
1691 String parameterId =
1692 updateIdenticalProperty(nodeTemplateId, propertyEntry.getKey(), nodeTemplate,
1693 unifiedCompositionEntity, unifiedCompositionDataList);
1696 parameterId, propertyType,
1697 propertyType.equals(PropertyType.LIST.getDisplayName()) ? propertyDefinition
1698 .getEntry_schema() : null,
1699 substitutionServiceTemplate);
1701 Optional<String> parameterId =
1702 updateProperty(serviceTemplate, nodeTemplateId, nodeTemplate, propertyEntry,
1703 unifiedCompositionEntity, computeTemplateConsolidationData,
1704 unifiedCompositionDataList,
1706 //todo - define list of type which will match the node property type (instead of string)
1707 addPropertyInputParameter(propertyType, substitutionServiceTemplate, parameterId);
1713 private void handleNodeTypeProperties(ServiceTemplate substitutionServiceTemplate,
1714 List<EntityConsolidationData> entityConsolidationDataList,
1715 NodeTemplate nodeTemplate,
1716 UnifiedCompositionEntity compositionEntity,
1717 ComputeTemplateConsolidationData
1718 computeTemplateConsolidationData,
1719 TranslationContext context) {
1720 ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1721 Optional<NodeType> enrichNodeType = Optional.empty();
1722 List<String> enrichProperties = new ArrayList<>();
1724 if (compositionEntity.equals(UnifiedCompositionEntity.Port)) {
1726 toscaAnalyzerService.fetchNodeType(ToscaNodeType.NETWORK_PORT,
1727 context.getGlobalServiceTemplates().values());
1728 enrichProperties = context.getEnrichPortResourceProperties();
1729 if (!enrichNodeType.isPresent() || Objects.isNull(enrichProperties)) {
1736 Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
1737 Map<String, PropertyDefinition> enrichNodeTypeProperties = enrichNodeType.get().getProperties();
1738 if (Objects.nonNull(enrichNodeTypeProperties)) {
1739 for (String enrichPropertyName : enrichProperties) {
1740 if (!nodeTemplateProperties.containsKey(enrichPropertyName)) {
1741 for (EntityConsolidationData entityConsolidationData : entityConsolidationDataList) {
1742 String nodeTemplateId = entityConsolidationData.getNodeTemplateId();
1743 String inputParamId =
1744 getParameterId(nodeTemplateId, nodeTemplate, enrichPropertyName,
1745 compositionEntity, computeTemplateConsolidationData);
1746 Map<String, List<String>> propertyVal = getPropertyValueInputParam(nodeTemplateId,
1747 nodeTemplate, inputParamId);
1748 nodeTemplate.getProperties().put(enrichPropertyName, propertyVal);
1749 String propertyType =
1750 enrichNodeType.get().getProperties().get(enrichPropertyName).getType();
1751 addPropertyInputParameter(propertyType, substitutionServiceTemplate,
1752 Optional.of(inputParamId));
1760 private void addPropertyInputParameter(String propertyType,
1761 ServiceTemplate substitutionServiceTemplate,
1762 Optional<String> parameterId) {
1763 if (propertyType.equalsIgnoreCase(PropertyType.STRING.getDisplayName())
1764 || propertyType.equalsIgnoreCase(PropertyType.INTEGER.getDisplayName())
1765 || propertyType.equalsIgnoreCase(PropertyType.FLOAT.getDisplayName())
1766 || propertyType.equalsIgnoreCase(PropertyType.BOOLEAN.getDisplayName())) {
1768 .ifPresent(parameterIdValue -> addInputParameter(parameterIdValue,
1769 PropertyType.LIST.getDisplayName(),
1771 .createEntrySchema(propertyType.toLowerCase(), null, null),
1772 substitutionServiceTemplate));
1775 .ifPresent(parameterIdValue -> addInputParameter(parameterIdValue,
1776 PropertyType.LIST.getDisplayName(),
1778 .createEntrySchema(PropertyTypeExt.JSON.getDisplayName(), null, null),
1779 substitutionServiceTemplate));
1783 private void handleConsolidationEntitiesRequirementConnectivity(String nodeTemplateId,
1784 NodeTemplate nodeTemplate,
1786 substitutionServiceTemplate,
1787 TranslationContext context) {
1788 Map<String, RequirementAssignment> updatedNodeTemplateRequirements = new HashMap<>();
1789 List<Map<String, RequirementAssignment>> nodeTemplateRequirements = DataModelUtil
1790 .getNodeTemplateRequirementList(nodeTemplate);
1791 if (CollectionUtils.isEmpty(nodeTemplateRequirements)) {
1795 for (Map<String, RequirementAssignment> requirement : nodeTemplateRequirements) {
1796 for (Map.Entry<String, RequirementAssignment> entry : requirement.entrySet()) {
1797 RequirementAssignment requirementAssignment = entry.getValue();
1798 String requirementNode = requirementAssignment.getNode();
1799 String unifiedNodeTemplateId =
1800 context.getUnifiedSubstitutionNodeTemplateId(substitutionServiceTemplate,
1802 if (unifiedNodeTemplateId != null) {
1803 //Update the node id in the requirement
1804 requirementAssignment.setNode(unifiedNodeTemplateId);
1808 nodeTemplate.setRequirements(nodeTemplateRequirements);
1812 * Update the node references in the volume relationship templates.
1814 * @param serviceTemplate the service template
1815 * @param context the context
1817 private void updateVolumeRelationshipTemplate(ServiceTemplate serviceTemplate,
1818 String relationshipId,
1819 TranslationContext context) {
1820 Map<String, RelationshipTemplate> relationshipTemplates = DataModelUtil
1821 .getRelationshipTemplates(serviceTemplate);
1822 if (relationshipTemplates != null) {
1823 RelationshipTemplate relationshipTemplate = relationshipTemplates.get(relationshipId);
1824 if (relationshipTemplate != null) {
1825 String relationshipTemplateType = relationshipTemplate.getType();
1826 if (relationshipTemplateType.equals(ToscaRelationshipType.CINDER_VOLUME_ATTACHES_TO)) {
1827 handleCinderVolumeAttachmentRelationshipTemplate(serviceTemplate,
1828 relationshipTemplate, context);
1835 private void handleCinderVolumeAttachmentRelationshipTemplate(ServiceTemplate
1836 substitutionServiceTemplate,
1837 RelationshipTemplate
1838 relationshipTemplate,
1839 TranslationContext context) {
1840 Map<String, Object> properties = relationshipTemplate.getProperties();
1841 properties.computeIfPresent(HeatConstants.INSTANCE_UUID_PROPERTY_NAME, (key, value) ->
1842 context.getUnifiedAbstractNodeTemplateId(substitutionServiceTemplate,
1846 private String updateIdenticalProperty(String nodeTemplateId, String propertyId,
1847 NodeTemplate nodeTemplate,
1848 UnifiedCompositionEntity unifiedCompositionEntity,
1849 List<UnifiedCompositionData> unifiedCompositionDataList) {
1851 String inputParamId;
1852 Map<String, Object> propertyVal = new HashMap<>();
1854 switch (unifiedCompositionEntity) {
1856 inputParamId = COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX + propertyId
1857 + COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX;
1859 propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
1860 nodeTemplate.getProperties().put(propertyId, propertyVal);
1862 return inputParamId;
1865 String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
1866 ComputeTemplateConsolidationData computeTemplateConsolidationData =
1867 getConnectedComputeConsolidationData(unifiedCompositionDataList, nodeTemplateId);
1868 inputParamId = getInputParamIdForPort(nodeTemplateId, propertyId, portType,
1869 computeTemplateConsolidationData);
1871 propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), inputParamId);
1872 nodeTemplate.getProperties().put(propertyId, propertyVal);
1874 return inputParamId;
1881 private String getInputParamIdForPort(String nodeTemplateId, String propertyId, String portType,
1882 ComputeTemplateConsolidationData computeTemplateConsolidationData) {
1883 String inputParamId;
1884 if (Objects.isNull(computeTemplateConsolidationData)
1885 || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
1887 UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_" +
1892 UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_"
1895 return inputParamId;
1898 private void addInputParameter(String parameterId,
1899 String parameterType,
1900 EntrySchema entrySchema,
1901 ServiceTemplate serviceTemplate) {
1903 ParameterDefinition parameterDefinition =
1904 DataModelUtil.createParameterDefinition(parameterType, null, null,
1905 true, null, null, entrySchema, null);
1907 .addInputParameterToTopologyTemplate(serviceTemplate, parameterId, parameterDefinition);
1910 // Return the input parameter Id which is used in the new property value if there is one
1911 private Optional<String> updateProperty(
1912 ServiceTemplate serviceTemplate,
1913 String nodeTemplateId, NodeTemplate nodeTemplate,
1914 Map.Entry<String, Object> propertyEntry,
1915 UnifiedCompositionEntity compositionEntity,
1916 ComputeTemplateConsolidationData computeTemplateConsolidationData,
1917 List<UnifiedCompositionData> unifiedCompositionDataList,
1918 TranslationContext context) {
1920 if (handleGetAttrFromConsolidationNodes(serviceTemplate, nodeTemplate, propertyEntry,
1921 unifiedCompositionDataList, context)) {
1922 return Optional.empty();
1924 String inputParamId =
1925 getParameterId(nodeTemplateId, nodeTemplate, propertyEntry.getKey(), compositionEntity,
1926 computeTemplateConsolidationData);
1927 Map<String, List<String>> propertyVal = getPropertyValueInputParam(nodeTemplateId,
1928 nodeTemplate, inputParamId);
1929 nodeTemplate.getProperties().put(propertyEntry.getKey(), propertyVal);
1930 return Optional.of(inputParamId);
1933 private Map<String, List<String>> getPropertyValueInputParam(String nodeTemplateId,
1934 NodeTemplate nodeTemplate,
1935 String inputParamId) {
1936 Map<String, List<String>> propertyVal = new HashMap<>();
1937 List<String> getInputFuncParams = new ArrayList<>();
1938 getInputFuncParams.add(inputParamId);
1939 getInputFuncParams.add(ToscaConstants.INDEX_VALUE_PROPERTY_NAME);
1940 propertyVal.put(ToscaFunctions.GET_INPUT.getDisplayName(), getInputFuncParams);
1944 private boolean handleGetAttrFromConsolidationNodes(
1945 ServiceTemplate serviceTemplate,
1946 NodeTemplate nodeTemplate,
1947 Map.Entry<String, Object> propertyEntry,
1948 List<UnifiedCompositionData> unifiedCompositionDataList,
1949 TranslationContext context) {
1950 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType =
1951 getAllConsolidationNodeTemplateIdAndType(unifiedCompositionDataList);
1953 Set<String> consolidationNodeTemplateIds = consolidationNodeTemplateIdAndType.keySet();
1954 boolean includeGetAttrFromConsolidationNodes = false;
1955 boolean includeGetAttrFromOutsideNodes = false;
1956 List<List<Object>> getAttrFunctionList = extractGetAttrFunction(propertyEntry.getValue());
1957 for (List<Object> getAttrFunc : getAttrFunctionList) {
1958 if (consolidationNodeTemplateIds.contains(getAttrFunc.get(0))) {
1959 includeGetAttrFromConsolidationNodes = true;
1961 includeGetAttrFromOutsideNodes = true;
1964 if ((includeGetAttrFromConsolidationNodes && includeGetAttrFromOutsideNodes)
1966 (includeGetAttrFromConsolidationNodes && isIncludeGetInputFunc(propertyEntry.getValue()))) {
1967 //This case is currently not supported - this property will be ignored
1969 } else if (includeGetAttrFromConsolidationNodes) {
1970 Object clonedPropertyValue = getClonedPropertyValue(propertyEntry);
1971 List<List<Object>> clonedGetAttrFuncList = extractGetAttrFunction(clonedPropertyValue);
1972 for (List<Object> getAttrFunc : clonedGetAttrFuncList) {
1973 String targetNodeTemplateId = (String) getAttrFunc.get(0);
1974 if (consolidationNodeTemplateIds.contains(targetNodeTemplateId)) {
1975 updatePropertyGetAttrFunc(serviceTemplate, unifiedCompositionDataList, context,
1976 consolidationNodeTemplateIdAndType, targetNodeTemplateId, getAttrFunc);
1979 nodeTemplate.getProperties().put(propertyEntry.getKey(), clonedPropertyValue);
1985 private void updatePropertyGetAttrFunc(
1986 ServiceTemplate serviceTemplate,
1987 List<UnifiedCompositionData> unifiedCompositionDataList,
1988 TranslationContext context,
1989 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType,
1990 String targetNodeTemplateId,
1991 List<Object> getAttrFunc) {
1992 UnifiedCompositionEntity targetCompositionEntity =
1993 consolidationNodeTemplateIdAndType.get(targetNodeTemplateId);
1994 String targetNewNodeTemplateId =
1995 getNewNodeTemplateId(serviceTemplate, unifiedCompositionDataList, targetNodeTemplateId,
1996 targetCompositionEntity);
1997 getAttrFunc.set(0, targetNewNodeTemplateId);
2000 private String getNewNodeTemplateId(ServiceTemplate serviceTemplate,
2001 List<UnifiedCompositionData> unifiedCompositionDataList,
2002 String nodeTemplateId,
2003 UnifiedCompositionEntity compositionEntity) {
2004 switch (compositionEntity) {
2006 return getNewComputeNodeTemplateId(serviceTemplate, nodeTemplateId);
2008 ComputeTemplateConsolidationData connectedComputeConsolidationData =
2009 getConnectedComputeConsolidationData(
2010 unifiedCompositionDataList, nodeTemplateId);
2011 NodeTemplate connectedComputeNodeTemplate =
2012 DataModelUtil.getNodeTemplate(serviceTemplate,
2013 connectedComputeConsolidationData.getNodeTemplateId());
2014 return getNewPortNodeTemplateId(nodeTemplateId, connectedComputeNodeTemplate.getType(),
2015 connectedComputeConsolidationData);
2021 private String getNewNodeTemplateId(String origNodeTemplateId,
2022 String serviceTemplateFileName,
2023 ServiceTemplate serviceTemplate,
2024 TranslationContext context) {
2025 ConsolidationData consolidationData = context.getConsolidationData();
2027 if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Port,
2028 serviceTemplateFileName,
2030 return handleIdOfPort(origNodeTemplateId, serviceTemplateFileName, consolidationData);
2031 } else if (isIdIsOfExpectedType(origNodeTemplateId, UnifiedCompositionEntity.Compute,
2032 serviceTemplateFileName, context)) {
2033 NodeTemplate nodeTemplate =
2034 getComputeNodeTemplate(origNodeTemplateId, serviceTemplate, context);
2035 return getComputeTypeSuffix(nodeTemplate.getType());
2041 private ComputeTemplateConsolidationData getConnectedComputeConsolidationData(
2042 List<UnifiedCompositionData> unifiedCompositionDataList,
2043 String portNodeTemplateId) {
2044 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
2045 Collection<List<String>> portsCollection =
2046 unifiedCompositionData.getComputeTemplateConsolidationData().getPorts().values();
2047 for (List<String> portIdList : portsCollection) {
2048 if (portIdList.contains(portNodeTemplateId)) {
2049 return unifiedCompositionData.getComputeTemplateConsolidationData();
2051 // for (String portId : portIdList) {
2052 // if (portId.equals(portNodeTemplateId)) {
2053 // return unifiedCompositionData.getComputeTemplateConsolidationData();
2061 private Object getClonedPropertyValue(Map.Entry<String, Object> propertyEntry) {
2062 if (propertyEntry.getValue() instanceof Map) {
2063 return getClonedObject(propertyEntry.getValue(), Map.class);
2064 } else if (propertyEntry.getValue() instanceof List) {
2065 return getClonedObject(propertyEntry.getValue(), List.class);
2067 return propertyEntry.getValue();
2071 private String getParameterId(String nodeTemplateId, NodeTemplate nodeTemplate, String propertyId,
2072 UnifiedCompositionEntity unifiedCompositionEntity,
2073 ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2074 switch (unifiedCompositionEntity) {
2076 return UnifiedCompositionEntity.Compute.name().toLowerCase() + "_"
2077 + getComputeTypeSuffix(nodeTemplate.getType()) + "_" + propertyId;
2079 String portType = ConsolidationDataUtil.getPortType(nodeTemplateId);
2080 if (Objects.isNull(computeTemplateConsolidationData)
2081 || computeTemplateConsolidationData.getPorts().get(portType).size() > 1) {
2082 return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + nodeTemplateId + "_"
2085 return UnifiedCompositionEntity.Port.name().toLowerCase() + "_" + portType + "_"
2092 private void removeConnectivityOut(EntityConsolidationData entityConsolidationData,
2093 NodeTemplate nodeTemplate) {
2094 if (MapUtils.isEmpty(entityConsolidationData.getNodesConnectedOut())) {
2098 for (List<RequirementAssignmentData> requirementAssignmentDataList : entityConsolidationData
2099 .getNodesConnectedOut().values()) {
2100 for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
2101 DataModelUtil.removeRequirementsAssignment(nodeTemplate.getRequirements(),
2102 requirementAssignmentData.getRequirementId());
2104 if (nodeTemplate.getRequirements().isEmpty()) {
2105 nodeTemplate.setRequirements(null);
2110 private void removeVolumeConnectivity(
2111 ComputeTemplateConsolidationData computeTemplateConsolidationData,
2112 NodeTemplate computeNodeTemplate) {
2113 if (MapUtils.isEmpty(computeTemplateConsolidationData.getVolumes())) {
2116 Collection<List<RequirementAssignmentData>> volumeCollection =
2117 computeTemplateConsolidationData.getVolumes().values();
2118 for (List<RequirementAssignmentData> requirementAssignmentDataList : volumeCollection) {
2119 for (RequirementAssignmentData requirementAssignmentData : requirementAssignmentDataList) {
2120 DataModelUtil.removeRequirementsAssignment(computeNodeTemplate.getRequirements(),
2121 requirementAssignmentData.getRequirementId());
2124 if (computeNodeTemplate.getRequirements().isEmpty()) {
2125 computeNodeTemplate.setRequirements(null);
2129 private void createIndexInputParameter(ServiceTemplate substitutionServiceTemplate) {
2130 ParameterDefinition indexParameterDefinition =
2131 DataModelUtil.createParameterDefinition(PropertyType.INTEGER.getDisplayName(),
2132 "Index value of this substitution service template runtime instance", null,
2133 false, createIndexValueConstraint(), null, null, 0);
2134 DataModelUtil.addInputParameterToTopologyTemplate(substitutionServiceTemplate,
2135 ToscaConstants.INDEX_VALUE_PROPERTY_NAME, indexParameterDefinition);
2139 private List<Constraint> createIndexValueConstraint() {
2140 List<Constraint> constraints;
2141 constraints = new ArrayList<>();
2142 Constraint constraint = new Constraint();
2143 constraint.setGreater_or_equal(0);
2144 constraints.add(constraint);
2148 private Optional<UnifiedComposition> getUnifiedCompositionInstance(UnifiedCompositionMode mode) {
2149 String unifiedCompositionImplClassName =
2150 unifiedCompositionImplMap.get(mode.name()).getImplementationClass();
2151 if (StringUtils.isEmpty(unifiedCompositionImplClassName)) {
2152 return Optional.empty();
2155 .of(CommonMethods.newInstance(unifiedCompositionImplClassName, UnifiedComposition.class));
2158 private Optional<Map<String, Object>> createAbstractSubstitutionProperties(
2159 ServiceTemplate serviceTemplate,
2160 ServiceTemplate substitutionServiceTemplate,
2161 List<UnifiedCompositionData> unifiedCompositionDataList,
2162 TranslationContext context) {
2163 Map<String, Object> abstractSubstituteProperties = new LinkedHashMap<>();
2164 Map<String, ParameterDefinition> substitutionTemplateInputs = DataModelUtil
2165 .getInputParameters(substitutionServiceTemplate);
2166 if (substitutionTemplateInputs == null) {
2167 return Optional.empty();
2169 //Since all the computes have the same type fetching the type from the first entry
2170 NodeTemplate firstComputeNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2171 unifiedCompositionDataList.get(0)
2172 .getComputeTemplateConsolidationData().getNodeTemplateId());
2173 String computeType = getComputeTypeSuffix(firstComputeNodeTemplate.getType());
2174 for (Map.Entry<String, ParameterDefinition> input : substitutionTemplateInputs.entrySet()) {
2175 String substitutionTemplateInputName = input.getKey();
2176 ParameterDefinition inputParameterDefinition = input.getValue();
2177 String inputType = inputParameterDefinition.getType();
2178 UnifiedCompositionEntity inputUnifiedCompositionEntity =
2179 getInputCompositionEntity(substitutionTemplateInputName);
2181 if (!inputType.equalsIgnoreCase(PropertyType.LIST.getDisplayName())) {
2182 if (isIdenticalValueProperty(
2183 substitutionTemplateInputName, inputUnifiedCompositionEntity, context)) {
2184 //Handle identical value properties
2185 Optional<String> identicalValuePropertyName =
2186 getIdenticalValuePropertyName(substitutionTemplateInputName,
2187 inputUnifiedCompositionEntity, context);
2189 if (identicalValuePropertyName.isPresent()) {
2190 updateIdenticalPropertyValue(identicalValuePropertyName.get(),
2191 substitutionTemplateInputName, computeType, inputUnifiedCompositionEntity,
2192 unifiedCompositionDataList.get(0), serviceTemplate, abstractSubstituteProperties);
2198 //Check if the input is of type compute or port
2199 List<Object> abstractPropertyValue = new ArrayList<>();
2200 Object propertyValue = null;
2201 switch (inputUnifiedCompositionEntity) {
2203 for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
2204 ComputeTemplateConsolidationData computeTemplateConsolidationData =
2205 compositionData.getComputeTemplateConsolidationData();
2206 propertyValue = getComputePropertyValue(substitutionTemplateInputName,
2207 serviceTemplate, computeTemplateConsolidationData);
2208 if (!(propertyValue instanceof Optional)) {
2209 abstractPropertyValue.add(propertyValue);
2214 for (UnifiedCompositionData compositionData : unifiedCompositionDataList) {
2215 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2216 getPortTemplateConsolidationDataList(compositionData);
2217 //Get the input type for this input whether it is of type
2218 // port_<port_node_template_id>_<property_name> or port_<port_type>_<property_name>
2219 PortInputType portInputType = getPortInputType(substitutionTemplateInputName,
2221 for (PortTemplateConsolidationData portTemplateConsolidationData :
2222 portTemplateConsolidationDataList) {
2223 //Get the port property value
2224 String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
2225 propertyValue = getPortPropertyValue(substitutionTemplateInputName,
2226 computeType, portInputType, serviceTemplate,
2227 portNodeTemplateId);
2228 //If the value object is Optional.empty it implies that the property name was not
2229 // found in the input name
2230 if (!(propertyValue instanceof Optional)) {
2231 abstractPropertyValue.add(propertyValue);
2239 //Add the property only if it has at least one non-null value
2240 for (Object val : abstractPropertyValue) {
2241 if (Objects.nonNull(val)) {
2242 abstractSubstituteProperties.put(substitutionTemplateInputName, abstractPropertyValue);
2247 return Optional.ofNullable(abstractSubstituteProperties);
2250 private void updateIdenticalPropertyValue(String identicalValuePropertyName,
2251 String substitutionTemplateInputName,
2253 UnifiedCompositionEntity entity,
2254 UnifiedCompositionData unifiedCompositionData,
2255 ServiceTemplate serviceTemplate,
2256 Map<String, Object> abstractSubstituteProperties){
2257 Optional<Object> identicalPropertyValueByType =
2258 getIdenticalPropertyValueByType(identicalValuePropertyName, substitutionTemplateInputName,
2259 computeType, entity, unifiedCompositionData, serviceTemplate);
2261 if(identicalPropertyValueByType.isPresent()){
2262 abstractSubstituteProperties
2263 .put(substitutionTemplateInputName, identicalPropertyValueByType.get());
2270 private Optional<Object> getIdenticalPropertyValueByType(String identicalValuePropertyName,
2271 String substitutionTemplateInputName,
2273 UnifiedCompositionEntity entity,
2274 UnifiedCompositionData unifiedCompositionData,
2275 ServiceTemplate serviceTemplate) {
2277 ComputeTemplateConsolidationData computeTemplateConsolidationData =
2278 unifiedCompositionData.getComputeTemplateConsolidationData();
2280 Optional<Object> computeIdenticalPropertyValue;
2283 computeIdenticalPropertyValue =
2284 getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2285 entity, computeTemplateConsolidationData);
2286 return computeIdenticalPropertyValue.isPresent() ? Optional.of(
2287 computeIdenticalPropertyValue.get()) : Optional.empty();
2290 computeIdenticalPropertyValue =
2291 getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2292 entity, computeTemplateConsolidationData);
2293 return computeIdenticalPropertyValue.isPresent() ? Optional.of(
2294 computeIdenticalPropertyValue.get()) : Optional.empty();
2297 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2298 unifiedCompositionData.getPortTemplateConsolidationDataList();
2299 for (PortTemplateConsolidationData portTemplateConsolidationData : portTemplateConsolidationDataList) {
2301 ConsolidationDataUtil.getPortType(portTemplateConsolidationData.getNodeTemplateId());
2302 if (substitutionTemplateInputName.contains(portType)) {
2303 return getIdenticalPropertyValue(identicalValuePropertyName, serviceTemplate,
2304 entity, portTemplateConsolidationData);
2309 return Optional.empty();
2314 private PortInputType getPortInputType(String inputName,
2315 UnifiedCompositionData unifiedCompositionData) {
2316 String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
2317 ComputeTemplateConsolidationData computeTemplateConsolidationData = unifiedCompositionData
2318 .getComputeTemplateConsolidationData();
2319 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2320 getPortTemplateConsolidationDataList(unifiedCompositionData);
2321 //Scan the available port node template ids to check if the input is of the form
2322 // "port_<port_node_template_id>_<property_name>"
2323 for (PortTemplateConsolidationData portTemplateConsolidationData :
2324 portTemplateConsolidationDataList) {
2325 String portNodeTemplateId = portTemplateConsolidationData.getNodeTemplateId();
2326 String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId;
2327 if (inputName.startsWith(portNodeTemplateIdPrefix)) {
2328 return PortInputType.NodeTemplateId;
2331 //Check whether the input is of the form "port_<port_type>_<property_name>"
2332 Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet();
2333 for (String portType : portTypes) {
2334 String expectedPortTypeSusbtring = portInputPrefix + portType + "_";
2335 if (inputName.startsWith(expectedPortTypeSusbtring)) {
2336 return PortInputType.PortType;
2339 return PortInputType.Other;
2342 private void cleanServiceTemplate(ServiceTemplate serviceTemplate,
2343 EntityConsolidationData entity,
2344 TranslationContext context) {
2345 removeNodeTemplateFromServiceTemplate(serviceTemplate, entity, context);
2346 updateHeatStackGroup(serviceTemplate, entity, context);
2349 private void removeNodeTemplateFromServiceTemplate(ServiceTemplate serviceTemplate,
2350 EntityConsolidationData entity,
2351 TranslationContext context) {
2352 String nodeTemplateIdToRemove = entity.getNodeTemplateId();
2353 Map<String, NodeTemplate> nodeTemplates =
2354 serviceTemplate.getTopology_template().getNode_templates();
2355 NodeTemplate nodeTemplateToRemove =
2356 nodeTemplates.get(nodeTemplateIdToRemove);
2357 nodeTemplates.remove(nodeTemplateIdToRemove);
2359 context.addCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2360 nodeTemplateIdToRemove,
2361 entity.getClass() == ComputeTemplateConsolidationData.class
2362 ? UnifiedCompositionEntity.Compute
2363 : UnifiedCompositionEntity.Port,
2364 nodeTemplateToRemove);
2368 private void removeCleanedNodeType(String cleanedNodeTemplateId,
2369 ServiceTemplate serviceTemplate,
2370 TranslationContext context) {
2371 NodeTemplate cleanedNodeTemplate =
2373 .getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2374 cleanedNodeTemplateId);
2375 String typeToRemove = cleanedNodeTemplate.getType();
2377 if (Objects.nonNull(typeToRemove)
2378 && serviceTemplate.getNode_types().containsKey(typeToRemove)) {
2379 serviceTemplate.getNode_types().remove(typeToRemove);
2383 private void updateHeatStackGroup(ServiceTemplate serviceTemplate,
2384 EntityConsolidationData entity,
2385 TranslationContext context) {
2386 Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
2387 .getGroups() == null ? new HashMap<>()
2388 : serviceTemplate.getTopology_template().getGroups();
2389 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
2390 String nodeRelatedAbstractNodeId =
2391 context.getUnifiedAbstractNodeTemplateId(serviceTemplate, entity.getNodeTemplateId());
2393 for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
2394 GroupDefinition groupDefinition = groupEntry.getValue();
2395 if (isHeatStackGroup(groupDefinition.getType())) {
2396 updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nodeRelatedAbstractNodeId,
2402 private void updateGroupMembersWithNewUnifiedNodeTemplateId(
2403 EntityConsolidationData entity,
2404 String newNodetemplateId,
2405 Map.Entry<String, GroupDefinition> groupEntry) {
2406 List<String> members = groupEntry.getValue().getMembers();
2407 if (members.contains(entity.getNodeTemplateId())) {
2408 members.remove(entity.getNodeTemplateId());
2409 if (!members.contains(newNodetemplateId)) {
2410 members.add(newNodetemplateId);
2413 groupEntry.getValue().setMembers(members);
2416 private void updateHeatStackGroupNestedComposition(ServiceTemplate serviceTemplate,
2417 EntityConsolidationData entity,
2418 TranslationContext context) {
2419 Map<String, GroupDefinition> groups = serviceTemplate.getTopology_template()
2420 .getGroups() == null ? new HashMap<>() : serviceTemplate.getTopology_template().getGroups();
2421 String serviceTemplateFileName = ToscaUtil.getServiceTemplateFileName(serviceTemplate);
2422 Optional<String> nestedNodeTemplateId =
2423 context.getUnifiedNestedNodeTemplateId(serviceTemplateFileName, entity.getNodeTemplateId());
2424 if (nestedNodeTemplateId.isPresent()) {
2425 for (Map.Entry<String, GroupDefinition> groupEntry : groups.entrySet()) {
2426 GroupDefinition groupDefinition = groupEntry.getValue();
2427 if (isHeatStackGroup(groupDefinition.getType())) {
2428 updateGroupMembersWithNewUnifiedNodeTemplateId(entity, nestedNodeTemplateId.get(),
2435 private void handleNestedNodeTemplateInMainServiceTemplate(String nestedNodeTemplateId,
2436 ServiceTemplate mainServiceTemplate,
2437 ServiceTemplate nestedServiceTemplate,
2438 TranslationContext context) {
2439 NodeTemplate nestedNodeTemplate = DataModelUtil.getNodeTemplate(mainServiceTemplate,
2440 nestedNodeTemplateId);
2441 if (Objects.isNull(nestedNodeTemplate)) {
2445 Optional<String> unifiedNestedNodeTypeId = context
2446 .getUnifiedNestedNodeTypeId(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
2447 nestedNodeTemplate.getType());
2448 unifiedNestedNodeTypeId
2449 .ifPresent(unifiedNestedNodeTypeIdVal -> updateNestedNodeTemplate(
2450 unifiedNestedNodeTypeIdVal, nestedNodeTemplateId, nestedNodeTemplate,
2451 mainServiceTemplate, nestedServiceTemplate, context));
2454 private void handleSubstitutionMappingInNestedServiceTemplate(
2455 String newNestedNodeType,
2456 ServiceTemplate nestedServiceTemplate) {
2457 if (Objects.isNull(newNestedNodeType)) {
2461 SubstitutionMapping substitutionMappings =
2462 nestedServiceTemplate.getTopology_template().getSubstitution_mappings();
2463 substitutionMappings.setNode_type(newNestedNodeType);
2466 private void updateNestedNodeTemplate(String newNestedNodeTypeId,
2467 String nestedNodeTemplateId,
2468 NodeTemplate nestedNodeTemplate,
2469 ServiceTemplate mainServiceTemplate,
2470 ServiceTemplate nestedServiceTemplate,
2471 TranslationContext context) {
2472 String mainServiceTemplateName = ToscaUtil.getServiceTemplateFileName(mainServiceTemplate);
2474 context.getHandledNestedComputeNodeTemplateIndex(mainServiceTemplateName,
2475 newNestedNodeTypeId);
2476 String newNodeTemplateId =
2477 Constants.ABSTRACT_NODE_TEMPLATE_ID_PREFIX + getComputeTypeSuffix(newNestedNodeTypeId) +
2480 nestedNodeTemplate.setType(newNestedNodeTypeId);
2481 mainServiceTemplate.getTopology_template().getNode_templates().remove(nestedNodeTemplateId);
2482 mainServiceTemplate.getTopology_template().getNode_templates()
2483 .put(newNodeTemplateId, nestedNodeTemplate);
2486 .addUnifiedNestedNodeTemplateId(mainServiceTemplateName,
2487 nestedNodeTemplateId, newNodeTemplateId);
2490 private void handleNestedNodeTypesInGlobalSubstituteServiceTemplate(
2491 String origNestedNodeTypeId,
2492 String newNestedNodeTypeId,
2493 ServiceTemplate globalSubstitutionServiceTemplate,
2494 TranslationContext context) {
2495 Map<String, NodeType> nodeTypes = globalSubstitutionServiceTemplate.getNode_types();
2496 NodeType nested = DataModelUtil.getNodeType(globalSubstitutionServiceTemplate,
2497 origNestedNodeTypeId);
2498 setNewValuesForNestedNodeType(origNestedNodeTypeId, newNestedNodeTypeId, nested, nodeTypes);
2499 context.addUnifiedNestedNodeTypeId(Constants.GLOBAL_SUBSTITUTION_TYPES_TEMPLATE_NAME,
2500 origNestedNodeTypeId, newNestedNodeTypeId);
2503 private void setNewValuesForNestedNodeType(String origNestedNodeType,
2504 String newNestedNodeTypeId,
2506 Map<String, NodeType> nodeTypes) {
2507 if (Objects.nonNull(nested)) {
2508 nested.setDerived_from(ToscaNodeType.VFC_ABSTRACT_SUBSTITUTE);
2509 nodeTypes.remove(origNestedNodeType);
2510 nodeTypes.put(newNestedNodeTypeId, nested);
2514 private Optional<String> getNewNestedNodeTypeId(ServiceTemplate mainServiceTemplate,
2515 ServiceTemplate nestedServiceTemplate,
2516 TranslationContext context) {
2517 FileComputeConsolidationData fileComputeConsolidationData =
2518 context.getConsolidationData().getComputeConsolidationData()
2519 .getFileComputeConsolidationData(
2520 ToscaUtil.getServiceTemplateFileName(nestedServiceTemplate));
2522 if (Objects.nonNull(fileComputeConsolidationData)) {
2523 String nestedNodeTypePrefix = ToscaNodeType.ABSTRACT_NODE_TYPE_PREFIX + "heat.";
2525 .of(nestedNodeTypePrefix + getComputeTypeInNestedFile(fileComputeConsolidationData));
2527 return Optional.empty();
2530 private String getComputeTypeInNestedFile(
2531 FileComputeConsolidationData fileComputeConsolidationData) {
2532 List<TypeComputeConsolidationData> typeComputeConsolidationDatas =
2533 new ArrayList<>(fileComputeConsolidationData.getAllTypeComputeConsolidationData());
2534 if (typeComputeConsolidationDatas.size() == 0) {
2537 String computeNodeType = fileComputeConsolidationData.getAllComputeTypes().iterator().next();
2538 return getComputeTypeSuffix(computeNodeType);
2542 private void handleGetAttrInAbstractNodeTemplate(ServiceTemplate serviceTemplate,
2543 TranslationContext context,
2544 String serviceTemplateFileName,
2545 NodeTemplate abstractNodeTemplate) {
2546 Map<String, Object> properties =
2547 abstractNodeTemplate == null || abstractNodeTemplate.getProperties() == null
2549 : abstractNodeTemplate.getProperties();
2550 for (Object propertyValue : properties.values()) {
2551 List<List<Object>> getAttrList = extractGetAttrFunction(propertyValue);
2552 for (List<Object> getAttrFuncValue : getAttrList) {
2553 String origNodeTemplateId = (String) getAttrFuncValue.get(0);
2554 Optional<String> nestedNodeTemplateId = context.getUnifiedNestedNodeTemplateId(ToscaUtil
2555 .getServiceTemplateFileName(serviceTemplate), origNodeTemplateId);
2556 if (nestedNodeTemplateId.isPresent()) {
2557 getAttrFuncValue.set(0, nestedNodeTemplateId.get());
2559 replaceGetAttrNodeIdAndAttrName(serviceTemplate, context, serviceTemplateFileName,
2566 private void replaceGetAttrNodeIdAndAttrName(ServiceTemplate serviceTemplate,
2567 TranslationContext context,
2568 String serviceTemplateFileName,
2569 List<Object> getAttrFuncValue) {
2570 String origNodeTemplateId = (String) getAttrFuncValue.get(0);
2571 String attributeName = (String) getAttrFuncValue.get(1);
2573 String unifiedAbstractNodeTemplateId =
2574 context.getUnifiedAbstractNodeTemplateId(serviceTemplate, origNodeTemplateId);
2576 if (Objects.isNull(unifiedAbstractNodeTemplateId)) {
2580 String newNodeTemplateId =
2581 getNewNodeTemplateId(origNodeTemplateId, serviceTemplateFileName, serviceTemplate, context);
2583 String newSubstitutionOutputParameterId =
2584 getNewSubstitutionOutputParameterId(newNodeTemplateId, attributeName);
2586 getAttrFuncValue.set(0, unifiedAbstractNodeTemplateId);
2587 getAttrFuncValue.set(1, newSubstitutionOutputParameterId);
2590 private NodeTemplate getComputeNodeTemplate(String origNodeTemplateId,
2591 ServiceTemplate serviceTemplate,
2592 TranslationContext context) {
2593 NodeTemplate computeNodeTemplate =
2594 DataModelUtil.getNodeTemplate(serviceTemplate, origNodeTemplateId);
2595 if (computeNodeTemplate == null) {
2596 computeNodeTemplate =
2597 context.getCleanedNodeTemplate(ToscaUtil.getServiceTemplateFileName(serviceTemplate),
2598 origNodeTemplateId);
2600 return computeNodeTemplate;
2603 private String handleIdOfPort(String origNodeTemplateId, String serviceTemplateFileName,
2604 ConsolidationData consolidationData) {
2605 Optional<Pair<String, ComputeTemplateConsolidationData>>
2606 computeTypeAndComputeTemplateByPortId =
2607 getComputeTypeAndComputeTemplateByPortId(origNodeTemplateId, serviceTemplateFileName,
2609 if (computeTypeAndComputeTemplateByPortId.isPresent()) {
2610 Pair<String, ComputeTemplateConsolidationData> computeIdToComputeData =
2611 computeTypeAndComputeTemplateByPortId.get();
2612 return getNewPortNodeTemplateId(origNodeTemplateId, computeIdToComputeData.getKey(),
2613 computeIdToComputeData.getValue());
2619 private Optional<Pair<String, ComputeTemplateConsolidationData>>
2620 getComputeTypeAndComputeTemplateByPortId(String portId, String serviceTemplateFileName,
2621 ConsolidationData consolidationData) {
2622 FileComputeConsolidationData fileComputeConsolidationData =
2623 consolidationData.getComputeConsolidationData()
2624 .getFileComputeConsolidationData(serviceTemplateFileName);
2625 Set<String> computeTypes =
2626 fileComputeConsolidationData.getAllComputeTypes();
2628 for (String computeType : computeTypes) {
2629 Collection<ComputeTemplateConsolidationData> computeTemplateConsolidationDatas =
2630 fileComputeConsolidationData.getTypeComputeConsolidationData(computeType)
2631 .getAllComputeTemplateConsolidationData();
2633 for (ComputeTemplateConsolidationData compute : computeTemplateConsolidationDatas) {
2634 if (ConsolidationDataUtil.isComputeReferenceToPortId(compute, portId)) {
2635 return Optional.of(new ImmutablePair<>(computeType, compute));
2640 return Optional.empty();
2643 private boolean isIdIsOfExpectedType(String id,
2644 UnifiedCompositionEntity expectedUnifiedCompositionEntity,
2645 String serviceTemplateFileName,
2646 TranslationContext context) {
2647 UnifiedSubstitutionData unifiedSubstitutionData =
2648 context.getUnifiedSubstitutionData().get(serviceTemplateFileName);
2649 if (Objects.isNull(unifiedSubstitutionData)) {
2653 UnifiedCompositionEntity actualUnifiedCompositionEntity =
2654 unifiedSubstitutionData.getCleanedNodeTemplateCompositionEntity(id);
2656 return actualUnifiedCompositionEntity == null ? false
2657 : actualUnifiedCompositionEntity.equals(expectedUnifiedCompositionEntity);
2660 private boolean isHeatStackGroup(String groupType) {
2661 return groupType.equals(ToscaGroupType.HEAT_STACK);
2664 private Object getPortPropertyValue(String inputName,
2666 PortInputType portInputType,
2667 ServiceTemplate serviceTemplate,
2668 String portNodeTemplateId) {
2669 //Get the input prefix to extract the property name from the input name
2670 String portInputPrefix = getPortInputPrefix(
2671 portNodeTemplateId, portInputType);
2672 //Get the property name from the input
2673 Optional<String> propertyName = getPropertyNameFromInput(inputName,
2674 UnifiedCompositionEntity.Port, computeType, portInputPrefix);
2675 //Get the property value from the node template
2676 if (propertyName.isPresent()) {
2677 NodeTemplate portNodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2678 portNodeTemplateId);
2679 if (Objects.nonNull(portNodeTemplate)) {
2680 return getPropertyValueFromNodeTemplate(propertyName.get(), portNodeTemplate);
2683 return Optional.empty();
2686 private Optional<String> getPortTypeFromInput(
2688 String portNodeTemplateId,
2689 ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2690 String portTypeFromInput = null;
2691 String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
2692 String portNodeTemplateIdPrefix = portInputPrefix + portNodeTemplateId;
2693 if (inputName.startsWith(portNodeTemplateIdPrefix)) {
2694 return Optional.empty();
2696 Set<String> portTypes = computeTemplateConsolidationData.getPorts().keySet();
2697 for (String portType : portTypes) {
2698 String expectedPortTypeSusbtring = "_" + portType + "_";
2699 if (inputName.contains(expectedPortTypeSusbtring)) {
2700 portTypeFromInput = portType;
2704 return Optional.ofNullable(portTypeFromInput);
2707 private Object getComputePropertyValue(
2709 ServiceTemplate serviceTemplate,
2710 ComputeTemplateConsolidationData computeTemplateConsolidationData) {
2711 NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2712 computeTemplateConsolidationData.getNodeTemplateId());
2713 String nodeType = getComputeTypeSuffix(nodeTemplate.getType());
2714 Optional<String> propertyName =
2715 getPropertyNameFromInput(inputName, UnifiedCompositionEntity.Compute, nodeType, null);
2716 if (propertyName.isPresent()) {
2717 return getPropertyValueFromNodeTemplate(propertyName.get(), nodeTemplate);
2719 return Optional.empty();
2722 private Optional<Object> getIdenticalPropertyValue(String identicalValuePropertyName,
2723 ServiceTemplate serviceTemplate,
2724 UnifiedCompositionEntity unifiedCompositionEntity,
2725 EntityConsolidationData entity){
2726 NodeTemplate nodeTemplate = DataModelUtil.getNodeTemplate(serviceTemplate,
2727 entity.getNodeTemplateId());
2729 Object propertyValueFromNodeTemplate =
2730 getPropertyValueFromNodeTemplate(identicalValuePropertyName, nodeTemplate);
2732 return Objects.isNull(propertyValueFromNodeTemplate) ? Optional.empty()
2733 :Optional.of(propertyValueFromNodeTemplate);
2736 private UnifiedCompositionEntity getInputCompositionEntity(String inputName) {
2737 UnifiedCompositionEntity inputCompositionEntity = UnifiedCompositionEntity.Other;
2738 String inputType = inputName.substring(0, inputName.indexOf('_'));
2739 if (inputType.equals(UnifiedCompositionEntity.Compute.name().toLowerCase())) {
2740 inputCompositionEntity = UnifiedCompositionEntity.Compute;
2741 } else if (inputType.equals(UnifiedCompositionEntity.Port.name().toLowerCase())) {
2742 inputCompositionEntity = UnifiedCompositionEntity.Port;
2744 return inputCompositionEntity;
2747 private Optional<String> getPropertyNameFromInput(
2749 UnifiedCompositionEntity compositionEntity,
2750 String computeType, String portInputPrefix) {
2751 String propertyName = null;
2752 switch (compositionEntity) {
2754 propertyName = inputName.substring(inputName.lastIndexOf(computeType)
2755 + computeType.length() + 1);
2758 if (inputName.startsWith(portInputPrefix)) {
2759 propertyName = inputName.split(portInputPrefix)[1];
2765 return Optional.ofNullable(propertyName);
2768 private String getPortInputPrefix(
2769 String portNodeTemplateId,
2770 PortInputType portInputType) {
2771 String portInputPrefix = UnifiedCompositionEntity.Port.name().toLowerCase() + "_";
2772 String portType = ConsolidationDataUtil.getPortType(portNodeTemplateId);
2773 if (portInputType == PortInputType.NodeTemplateId) {
2774 portInputPrefix += portNodeTemplateId + "_";
2775 } else if (portInputType == PortInputType.PortType) {
2776 portInputPrefix += portType + "_";
2778 return portInputPrefix;
2781 private boolean isIdenticalValueProperty(String inputName,
2782 UnifiedCompositionEntity unifiedCompositionEntity,
2783 TranslationContext context) {
2785 List<String> identicalValuePropertyList =
2786 consolidationService.getPropertiesWithIdenticalVal(unifiedCompositionEntity, context);
2788 StringBuilder builder = getPropertyValueStringBuilder(unifiedCompositionEntity);
2790 boolean isMatchingProperty = Pattern.matches(builder.toString(), inputName);
2791 return (isMatchingProperty
2792 && isPropertyFromIdenticalValuesList(inputName, unifiedCompositionEntity,
2793 identicalValuePropertyList));
2796 private boolean isPropertyFromIdenticalValuesList(String inputName,
2797 UnifiedCompositionEntity unifiedCompositionEntity,
2798 List<String> identicalValuePropertyList) {
2799 switch (unifiedCompositionEntity) {
2801 return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
2802 unifiedCompositionEntity, null).get());
2805 return identicalValuePropertyList.contains(getIdenticalValuePropertyName(inputName,
2806 unifiedCompositionEntity, null).get());
2809 return getPortPropertyNameFromInput(inputName, identicalValuePropertyList).isPresent();
2816 private Optional<String> getPortPropertyNameFromInput(String inputName,
2817 List<String> identicalValuePropertyList) {
2818 for (String identicalProperty : identicalValuePropertyList) {
2819 if (inputName.contains(identicalProperty)) {
2820 return Optional.of(identicalProperty);
2823 return Optional.empty();
2826 private StringBuilder getPropertyValueStringBuilder(
2827 UnifiedCompositionEntity unifiedCompositionEntity) {
2829 switch (unifiedCompositionEntity) {
2831 return getComputePropertyValueStringBuilder();
2834 return getComputePropertyValueStringBuilder();
2837 return getPortPropertyValueStringBuilder();
2844 private StringBuilder getPortPropertyValueStringBuilder() {
2845 StringBuilder builder;
2846 builder = new StringBuilder(PORT_IDENTICAL_VALUE_PROPERTY_PREFIX);
2847 builder.append(".+");
2851 private StringBuilder getComputePropertyValueStringBuilder() {
2852 StringBuilder builder;
2853 builder = new StringBuilder(COMPUTE_IDENTICAL_VALUE_PROPERTY_PREFIX);
2854 builder.append("[a-z]+");
2855 builder.append(COMPUTE_IDENTICAL_VALUE_PROPERTY_SUFFIX);
2859 private Optional<String> getIdenticalValuePropertyName(String input,
2860 UnifiedCompositionEntity unifiedCompositionEntity,
2861 TranslationContext context) {
2862 switch (unifiedCompositionEntity) {
2864 return Optional.of(input.split("_")[1]);
2867 return Optional.of(input.split("_")[1]);
2870 return getPortPropertyNameFromInput(input, consolidationService
2871 .getPropertiesWithIdenticalVal(unifiedCompositionEntity, context));
2874 return Optional.empty();
2878 private Object getPropertyValueFromNodeTemplate(String propertyName, NodeTemplate nodeTemplate) {
2879 Map<String, Object> nodeTemplateProperties = nodeTemplate.getProperties();
2880 if (nodeTemplateProperties != null) {
2881 Object propertyValue = nodeTemplateProperties.get(propertyName);
2882 propertyValue = getClonedObject(propertyValue);
2883 return propertyValue;
2888 private <T> Object getClonedObject(Object objectValue, Class<T> clazz) {
2889 YamlUtil yamlUtil = new YamlUtil();
2890 Object clonedObjectValue;
2891 String objectToYaml = yamlUtil.objectToYaml(objectValue);
2892 clonedObjectValue = yamlUtil.yamlToObject(objectToYaml, clazz);
2893 return clonedObjectValue;
2896 private Object getClonedObject(Object objectValue) {
2897 Object clonedObjectValue;
2899 ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
2900 ObjectOutputStream objectOutputStream = new ObjectOutputStream(byteArrayOutputStream);
2901 objectOutputStream.writeObject(objectValue);
2903 ByteArrayInputStream byteArrayInputStream = new ByteArrayInputStream(byteArrayOutputStream
2905 ObjectInputStream objectInputStream = new ObjectInputStream(byteArrayInputStream);
2906 clonedObjectValue = objectInputStream.readObject();
2907 } catch (NotSerializableException ex) {
2908 return getClonedObject(objectValue, objectValue.getClass());
2909 } catch (IOException ioe) {
2911 } catch (ClassNotFoundException cnfe) {
2914 return clonedObjectValue;
2917 private Map<String, UnifiedCompositionEntity> getAllConsolidationNodeTemplateIdAndType(
2918 List<UnifiedCompositionData> unifiedCompositionDataList) {
2920 Map<String, UnifiedCompositionEntity> consolidationNodeTemplateIdAndType = new HashMap<>();
2921 for (UnifiedCompositionData unifiedCompositionData : unifiedCompositionDataList) {
2922 ComputeTemplateConsolidationData computeTemplateConsolidationData =
2923 unifiedCompositionData.getComputeTemplateConsolidationData();
2924 if (Objects.nonNull(computeTemplateConsolidationData)) {
2925 consolidationNodeTemplateIdAndType
2926 .put(computeTemplateConsolidationData.getNodeTemplateId(),
2927 UnifiedCompositionEntity.Compute);
2929 List<PortTemplateConsolidationData> portTemplateConsolidationDataList =
2930 getPortTemplateConsolidationDataList(unifiedCompositionData);
2931 for (PortTemplateConsolidationData portTemplateConsolidationData :
2932 portTemplateConsolidationDataList) {
2933 consolidationNodeTemplateIdAndType.put(portTemplateConsolidationData.getNodeTemplateId(),
2934 UnifiedCompositionEntity.Port);
2936 NestedTemplateConsolidationData nestedTemplateConsolidationData =
2937 unifiedCompositionData.getNestedTemplateConsolidationData();
2938 if (Objects.nonNull(nestedTemplateConsolidationData)) {
2939 consolidationNodeTemplateIdAndType
2940 .put(nestedTemplateConsolidationData.getNodeTemplateId(),
2941 UnifiedCompositionEntity.Nested);
2944 return consolidationNodeTemplateIdAndType;
2947 private enum PortInputType {
2953 private List<PortTemplateConsolidationData> getPortTemplateConsolidationDataList(
2954 UnifiedCompositionData unifiedCompositionData) {
2955 return unifiedCompositionData.getPortTemplateConsolidationDataList() == null ? new
2956 ArrayList<>() : unifiedCompositionData.getPortTemplateConsolidationDataList();