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.tosca.services;
23 import org.apache.commons.collections4.CollectionUtils;
24 import org.apache.commons.collections4.MapUtils;
25 import org.openecomp.core.utilities.CommonMethods;
26 import org.openecomp.core.utilities.yaml.YamlUtil;
27 import org.openecomp.sdc.common.errors.CoreException;
28 import org.openecomp.sdc.datatypes.error.ErrorLevel;
29 import org.openecomp.sdc.logging.context.impl.MdcDataDebugMessage;
30 import org.openecomp.sdc.logging.context.impl.MdcDataErrorMessage;
31 import org.openecomp.sdc.logging.types.LoggerConstants;
32 import org.openecomp.sdc.logging.types.LoggerErrorCode;
33 import org.openecomp.sdc.logging.types.LoggerErrorDescription;
34 import org.openecomp.sdc.logging.types.LoggerTragetServiceName;
35 import org.openecomp.sdc.tosca.datatypes.ToscaFunctions;
36 import org.openecomp.sdc.tosca.datatypes.model.AttributeDefinition;
37 import org.openecomp.sdc.tosca.datatypes.model.CapabilityDefinition;
38 import org.openecomp.sdc.tosca.datatypes.model.CapabilityType;
39 import org.openecomp.sdc.tosca.datatypes.model.Constraint;
40 import org.openecomp.sdc.tosca.datatypes.model.EntrySchema;
41 import org.openecomp.sdc.tosca.datatypes.model.GroupDefinition;
42 import org.openecomp.sdc.tosca.datatypes.model.Import;
43 import org.openecomp.sdc.tosca.datatypes.model.NodeTemplate;
44 import org.openecomp.sdc.tosca.datatypes.model.NodeType;
45 import org.openecomp.sdc.tosca.datatypes.model.ParameterDefinition;
46 import org.openecomp.sdc.tosca.datatypes.model.PolicyDefinition;
47 import org.openecomp.sdc.tosca.datatypes.model.PropertyDefinition;
48 import org.openecomp.sdc.tosca.datatypes.model.RelationshipTemplate;
49 import org.openecomp.sdc.tosca.datatypes.model.RequirementAssignment;
50 import org.openecomp.sdc.tosca.datatypes.model.RequirementDefinition;
51 import org.openecomp.sdc.tosca.datatypes.model.ServiceTemplate;
52 import org.openecomp.sdc.tosca.datatypes.model.Status;
53 import org.openecomp.sdc.tosca.datatypes.model.SubstitutionMapping;
54 import org.openecomp.sdc.tosca.datatypes.model.TopologyTemplate;
55 import org.openecomp.sdc.tosca.datatypes.model.heatextend.ParameterDefinitionExt;
56 import org.openecomp.sdc.tosca.errors.InvalidAddActionNullEntityErrorBuilder;
57 import org.openecomp.sdc.tosca.errors.InvalidRequirementAssignmentErrorBuilder;
58 import org.openecomp.sdc.tosca.services.impl.ToscaAnalyzerServiceImpl;
59 import org.openecomp.sdc.tosca.services.yamlutil.ToscaExtensionYamlUtil;
61 import java.util.ArrayList;
62 import java.util.Arrays;
63 import java.util.Collections;
64 import java.util.HashMap;
65 import java.util.List;
66 import java.util.ListIterator;
68 import java.util.Objects;
69 import java.util.Optional;
72 * The type Data model util.
74 public class DataModelUtil {
77 * Add substitution mapping.
80 private static MdcDataDebugMessage mdcDataDebugMessage = new MdcDataDebugMessage();
83 * Add substitution mapping.
85 * @param serviceTemplate the service template
86 * @param substitutionMapping the substitution mapping
88 public static void addSubstitutionMapping(ServiceTemplate serviceTemplate,
89 SubstitutionMapping substitutionMapping) {
90 mdcDataDebugMessage.debugEntryMessage(null, null);
92 if (serviceTemplate == null) {
93 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
94 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
95 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
96 throw new CoreException(
97 new InvalidAddActionNullEntityErrorBuilder("Substitution Mapping", "Service Template")
101 if (serviceTemplate.getTopology_template() == null) {
102 serviceTemplate.setTopology_template(new TopologyTemplate());
104 serviceTemplate.getTopology_template().setSubstitution_mappings(substitutionMapping);
106 mdcDataDebugMessage.debugExitMessage(null, null);
110 * Add substitution mapping req.
112 * @param serviceTemplate the service template
113 * @param substitutionMappingRequirementId the substitution mapping requirement id
114 * @param substitutionMappingRequirementList the substitution mapping requirement list
116 public static void addSubstitutionMappingReq(ServiceTemplate serviceTemplate,
117 String substitutionMappingRequirementId,
118 List<String> substitutionMappingRequirementList) {
121 mdcDataDebugMessage.debugEntryMessage(null, null);
123 if (serviceTemplate == null) {
124 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
125 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
126 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
127 throw new CoreException(
128 new InvalidAddActionNullEntityErrorBuilder("Substitution Mapping Requirements",
129 "Service Template").build());
132 if (serviceTemplate.getTopology_template() == null) {
133 serviceTemplate.setTopology_template(new TopologyTemplate());
135 if (serviceTemplate.getTopology_template().getSubstitution_mappings() == null) {
136 serviceTemplate.getTopology_template().setSubstitution_mappings(new SubstitutionMapping());
138 if (serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements()
140 serviceTemplate.getTopology_template().getSubstitution_mappings()
141 .setRequirements(new HashMap<>());
144 serviceTemplate.getTopology_template().getSubstitution_mappings().getRequirements()
145 .put(substitutionMappingRequirementId, substitutionMappingRequirementList);
147 mdcDataDebugMessage.debugExitMessage(null, null);
153 * @param serviceTemplate the service template
154 * @param nodeTemplateId the node template id
155 * @param nodeTemplate the node template
157 public static void addNodeTemplate(ServiceTemplate serviceTemplate, String nodeTemplateId,
158 NodeTemplate nodeTemplate) {
161 mdcDataDebugMessage.debugEntryMessage(null, null);
163 if (serviceTemplate == null) {
164 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
165 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
166 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
167 throw new CoreException(
168 new InvalidAddActionNullEntityErrorBuilder("Node Template", "Service Template").build());
170 TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
171 if (Objects.isNull(topologyTemplate)) {
172 topologyTemplate = new TopologyTemplate();
173 serviceTemplate.setTopology_template(topologyTemplate);
175 if (topologyTemplate.getNode_templates() == null) {
176 topologyTemplate.setNode_templates(new HashMap<>());
178 topologyTemplate.getNode_templates().put(nodeTemplateId, nodeTemplate);
180 mdcDataDebugMessage.debugExitMessage(null, null);
185 * Add capability def.
187 * @param nodeType the node type
188 * @param capabilityId the capability id
189 * @param capabilityDefinition the capability definition
191 public static void addCapabilityDef(NodeType nodeType, String capabilityId,
192 CapabilityDefinition capabilityDefinition) {
195 mdcDataDebugMessage.debugEntryMessage(null, null);
197 if (nodeType == null) {
198 throw new CoreException(
199 new InvalidAddActionNullEntityErrorBuilder("Capability Definition", "Node Type").build());
201 if (Objects.isNull(nodeType.getCapabilities())) {
202 nodeType.setCapabilities(new HashMap<>());
204 nodeType.getCapabilities().put(capabilityId, capabilityDefinition);
206 mdcDataDebugMessage.debugExitMessage(null, null);
210 * Add capabilities def to node type.
212 * @param nodeType the node type
213 * @param capabilities the capability definitions
215 public static void addNodeTypeCapabilitiesDef(NodeType nodeType,
216 Map<String, CapabilityDefinition> capabilities) {
217 mdcDataDebugMessage.debugEntryMessage(null, null);
219 if (capabilities == null || capabilities.entrySet().size() == 0) {
223 if (nodeType == null) {
224 throw new CoreException(
225 new InvalidAddActionNullEntityErrorBuilder("Capability Definition", "Node Type").build());
228 if (MapUtils.isEmpty(nodeType.getCapabilities())) {
229 nodeType.setCapabilities(new HashMap<>());
231 if (capabilities.size() > 0) {
232 nodeType.setCapabilities(new HashMap<>());
234 for (Map.Entry<String, CapabilityDefinition> entry : capabilities.entrySet()) {
235 nodeType.getCapabilities().put(entry.getKey(), entry.getValue());
238 mdcDataDebugMessage.debugExitMessage(null, null);
242 * Add policy definition.
244 * @param serviceTemplate the service template
245 * @param policyId the policy id
246 * @param policyDefinition the policy definition
248 public static void addPolicyDefinition(ServiceTemplate serviceTemplate, String policyId,
249 PolicyDefinition policyDefinition) {
252 mdcDataDebugMessage.debugEntryMessage(null, null);
254 if (serviceTemplate == null) {
255 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
256 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
257 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
258 throw new CoreException(
259 new InvalidAddActionNullEntityErrorBuilder("Policy Definition", "Service Template")
262 TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
263 if (Objects.isNull(topologyTemplate)) {
264 topologyTemplate = new TopologyTemplate();
265 serviceTemplate.setTopology_template(topologyTemplate);
267 if (topologyTemplate.getPolicies() == null) {
268 topologyTemplate.setPolicies(new HashMap<>());
270 topologyTemplate.getPolicies().put(policyId, policyDefinition);
272 mdcDataDebugMessage.debugExitMessage(null, null);
278 * @param serviceTemplate the service template
279 * @param nodeTypeId the node type id
280 * @param nodeType the node type
282 public static void addNodeType(ServiceTemplate serviceTemplate, String nodeTypeId,
286 mdcDataDebugMessage.debugEntryMessage(null, null);
288 if (serviceTemplate == null) {
289 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
290 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
291 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
292 throw new CoreException(
293 new InvalidAddActionNullEntityErrorBuilder("Node Type", "Service Template").build());
295 if (serviceTemplate.getNode_types() == null) {
296 serviceTemplate.setNode_types(new HashMap<>());
298 serviceTemplate.getNode_types().put(nodeTypeId, nodeType);
300 mdcDataDebugMessage.debugExitMessage(null, null);
304 * Add relationship template.
306 * @param serviceTemplate the service template
307 * @param relationshipTemplateId the relationship template id
308 * @param relationshipTemplate the relationship template
310 public static void addRelationshipTemplate(ServiceTemplate serviceTemplate,
311 String relationshipTemplateId,
312 RelationshipTemplate relationshipTemplate) {
315 mdcDataDebugMessage.debugEntryMessage(null, null);
317 if (serviceTemplate == null) {
318 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
319 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
320 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
321 throw new CoreException(
322 new InvalidAddActionNullEntityErrorBuilder("Relationship Template", "Service Template")
325 if (serviceTemplate.getTopology_template() == null) {
326 serviceTemplate.setTopology_template(new TopologyTemplate());
328 if (serviceTemplate.getTopology_template().getRelationship_templates() == null) {
329 serviceTemplate.getTopology_template().setRelationship_templates(new HashMap<>());
331 serviceTemplate.getTopology_template().getRelationship_templates()
332 .put(relationshipTemplateId, relationshipTemplate);
334 mdcDataDebugMessage.debugExitMessage(null, null);
338 * Add requirement assignment.
340 * @param nodeTemplate the node template
341 * @param requirementId the requirement id
342 * @param requirementAssignment the requirement assignment
344 public static void addRequirementAssignment(NodeTemplate nodeTemplate, String requirementId,
345 RequirementAssignment requirementAssignment) {
348 mdcDataDebugMessage.debugEntryMessage(null, null);
350 if (nodeTemplate == null) {
351 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
352 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
353 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
354 throw new CoreException(
355 new InvalidAddActionNullEntityErrorBuilder("Requirement Assignment", "Node Template")
358 if (requirementAssignment.getNode() == null) {
359 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
360 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
361 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
362 throw new CoreException(new InvalidRequirementAssignmentErrorBuilder(requirementId).build());
365 if (nodeTemplate.getRequirements() == null) {
366 nodeTemplate.setRequirements(new ArrayList<>());
368 Map<String, RequirementAssignment> requirement = new HashMap<>();
369 requirement.put(requirementId, requirementAssignment);
370 nodeTemplate.getRequirements().add(requirement);
372 mdcDataDebugMessage.debugExitMessage(null, null);
376 * Gets node template.
378 * @param serviceTemplate the service template
379 * @param nodeTemplateId the node template id
380 * @return the node template
382 public static NodeTemplate getNodeTemplate(ServiceTemplate serviceTemplate,
383 String nodeTemplateId) {
385 mdcDataDebugMessage.debugEntryMessage(null, null);
387 if (serviceTemplate == null
388 || serviceTemplate.getTopology_template() == null
389 || serviceTemplate.getTopology_template().getNode_templates() == null) {
393 mdcDataDebugMessage.debugExitMessage(null, null);
394 return serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId);
400 * @param serviceTemplate the service template
401 * @param nodeTypeId the node type id
402 * @return the node type
404 public static NodeType getNodeType(ServiceTemplate serviceTemplate, String nodeTypeId) {
407 mdcDataDebugMessage.debugEntryMessage(null, null);
408 if (serviceTemplate == null || serviceTemplate.getNode_types() == null) {
412 mdcDataDebugMessage.debugExitMessage(null, null);
413 return serviceTemplate.getNode_types().get(nodeTypeId);
417 * Gets requirement definition.
419 * @param nodeType the node type
420 * @param requirementDefinitionId the requirement definition id
421 * @return the requirement definition
423 public static Optional<RequirementDefinition> getRequirementDefinition(
425 String requirementDefinitionId) {
428 mdcDataDebugMessage.debugEntryMessage(null, null);
430 if (nodeType == null || nodeType.getRequirements() == null || requirementDefinitionId == null) {
431 return Optional.empty();
433 for (Map<String, RequirementDefinition> reqMap : nodeType.getRequirements()) {
434 if (reqMap.containsKey(requirementDefinitionId)) {
435 return Optional.of(reqMap.get(requirementDefinitionId));
439 mdcDataDebugMessage.debugExitMessage(null, null);
440 return Optional.empty();
444 * get requirement defenition from requirement defenition list by req key.
446 * @param requirementsDefinitionList requirement defenition list
447 * @param requirementKey requirement key
449 public static Optional<RequirementDefinition> getRequirementDefinition(
450 List<Map<String, RequirementDefinition>> requirementsDefinitionList,
451 String requirementKey) {
452 mdcDataDebugMessage.debugEntryMessage(null, null);
453 if (CollectionUtils.isEmpty(requirementsDefinitionList)) {
454 return Optional.empty();
457 for (Map<String, RequirementDefinition> requirementMap : requirementsDefinitionList) {
458 if (requirementMap.containsKey(requirementKey)) {
459 mdcDataDebugMessage.debugExitMessage(null, null);
460 return Optional.of(requirementMap.get(requirementKey));
464 mdcDataDebugMessage.debugExitMessage(null, null);
465 return Optional.empty();
469 * Gets capability definition.
471 * @param nodeType the node type
472 * @param capabilityDefinitionId the capability definition id
473 * @return the capability definition
475 public static Optional<CapabilityDefinition> getCapabilityDefinition(
477 String capabilityDefinitionId) {
480 mdcDataDebugMessage.debugEntryMessage(null, null);
482 if (nodeType == null || nodeType.getCapabilities() == null || capabilityDefinitionId == null) {
483 return Optional.empty();
486 mdcDataDebugMessage.debugExitMessage(null, null);
487 return Optional.ofNullable(nodeType.getCapabilities().get(capabilityDefinitionId));
491 * Add group definition to topology template.
493 * @param serviceTemplate the service template
494 * @param groupName the group name
495 * @param group the group
497 public static void addGroupDefinitionToTopologyTemplate(ServiceTemplate serviceTemplate,
498 String groupName, GroupDefinition group) {
501 mdcDataDebugMessage.debugEntryMessage(null, null);
503 if (serviceTemplate == null) {
504 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
505 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
506 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
507 throw new CoreException(
508 new InvalidAddActionNullEntityErrorBuilder("Group Definition", "Service Template")
512 TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
513 if (Objects.isNull(topologyTemplate)) {
514 topologyTemplate = new TopologyTemplate();
515 serviceTemplate.setTopology_template(topologyTemplate);
517 if (topologyTemplate.getGroups() == null) {
518 topologyTemplate.setGroups(new HashMap<>());
520 if (serviceTemplate.getTopology_template().getGroups() == null) {
521 Map<String, GroupDefinition> groups = new HashMap<>();
522 serviceTemplate.getTopology_template().setGroups(groups);
525 serviceTemplate.getTopology_template().getGroups().put(groupName, group);
526 mdcDataDebugMessage.debugExitMessage(null, null);
530 * Create property definition property definition.
532 * @param type the type
533 * @param description the description
534 * @param required the required
535 * @param constraints the constraints
536 * @param status the status
537 * @param entrySchema the entry schema
538 * @param defaultVal the default val
539 * @return the property definition
541 public static PropertyDefinition createPropertyDefinition(String type, String description,
543 List<Constraint> constraints,
545 EntrySchema entrySchema,
549 mdcDataDebugMessage.debugEntryMessage(null, null);
551 PropertyDefinition propDef = new PropertyDefinition();
552 propDef.setType(type);
553 propDef.setDescription(description);
554 propDef.setRequired(required);
555 propDef.setConstraints(constraints);
556 if (status != null) {
557 propDef.setStatus(status);
559 propDef.setEntry_schema(entrySchema);
560 propDef.set_default(defaultVal);
562 mdcDataDebugMessage.debugExitMessage(null, null);
567 * Create parameter definition property definition.
569 * @param type the type
570 * @param description the description
571 * @param value the value
572 * @param required the required
573 * @param constraints the constraints
574 * @param status the status
575 * @param entrySchema the entry schema
576 * @param defaultVal the default val
577 * @return the property definition
579 public static ParameterDefinition createParameterDefinition(String type, String description,
580 Object value, boolean required,
581 List<Constraint> constraints,
583 EntrySchema entrySchema,
587 mdcDataDebugMessage.debugEntryMessage(null, null);
589 ParameterDefinition paramDef = new ParameterDefinition();
590 paramDef.setType(type);
591 paramDef.setDescription(description);
592 paramDef.setValue(value);
593 paramDef.setRequired(required);
594 paramDef.setConstraints(constraints);
595 if (status != null) {
596 paramDef.setStatus(status);
598 paramDef.setEntry_schema(entrySchema == null ? null : entrySchema.clone());
599 paramDef.set_default(defaultVal);
601 mdcDataDebugMessage.debugExitMessage(null, null);
606 * Create requirement requirement definition.
608 * @param capability the capability
609 * @param node the node
610 * @param relationship the relationship
611 * @param occurrences the occurrences
612 * @return the requirement definition
614 public static RequirementDefinition createRequirement(String capability, String node,
615 String relationship, Object[] occurrences) {
618 mdcDataDebugMessage.debugEntryMessage(null, null);
620 RequirementDefinition requirementDefinition = new RequirementDefinition();
621 requirementDefinition.setCapability(capability);
622 requirementDefinition.setNode(node);
623 requirementDefinition.setRelationship(relationship);
624 if (occurrences != null) {
625 requirementDefinition.setOccurrences(occurrences);
628 mdcDataDebugMessage.debugExitMessage(null, null);
629 return requirementDefinition;
633 * Create attribute definition attribute definition.
635 * @param type the type
636 * @param description the description
637 * @param status the status
638 * @param entrySchema the entry schema
639 * @param defaultVal the default val
640 * @return the attribute definition
642 public static AttributeDefinition createAttributeDefinition(String type, String description,
644 EntrySchema entrySchema,
648 mdcDataDebugMessage.debugEntryMessage(null, null);
650 AttributeDefinition attributeDef = new AttributeDefinition();
651 attributeDef.setType(type);
653 if (description != null) {
654 attributeDef.setDescription(description);
656 if (status != null) {
657 attributeDef.setStatus(status);
659 attributeDef.setEntry_schema(entrySchema);
660 attributeDef.set_default(defaultVal);
662 mdcDataDebugMessage.debugExitMessage(null, null);
667 * Create valid values constraint constraint.
669 * @param values the values
670 * @return the constraint
672 public static Constraint createValidValuesConstraint(Object... values) {
675 mdcDataDebugMessage.debugEntryMessage(null, null);
677 Constraint validValues = new Constraint();
678 for (Object value : values) {
679 validValues.addValidValue(value);
682 mdcDataDebugMessage.debugExitMessage(null, null);
687 * Create metadata metadata.
689 * @param templateName the template name
690 * @param templateVersion the template version
691 * @param templateAuthor the template author
692 * @return the metadata
694 public static Map<String, String> createMetadata(String templateName, String templateVersion,
695 String templateAuthor) {
698 mdcDataDebugMessage.debugEntryMessage(null, null);
699 Map<String, String> metadata = new HashMap<>();
700 metadata.put(ToscaConstants.ST_METADATA_TEMPLATE_NAME, templateName);
701 metadata.put("template_version", templateVersion);
702 metadata.put("template_author", templateAuthor);
704 mdcDataDebugMessage.debugExitMessage(null, null);
709 * Create entry schema entry schema.
711 * @param type the type
712 * @param description the description
713 * @param constraints the constraints
714 * @return the entry schema
716 public static EntrySchema createEntrySchema(String type, String description,
717 List<Constraint> constraints) {
720 mdcDataDebugMessage.debugEntryMessage(null, null);
722 if(Objects.isNull(type) && Objects.isNull(description) && CollectionUtils.isEmpty(constraints)){
726 EntrySchema entrySchema = new EntrySchema();
727 entrySchema.setType(type);
728 entrySchema.setDescription(description);
729 entrySchema.setConstraints(constraints);
731 mdcDataDebugMessage.debugExitMessage(null, null);
736 * Create valid values constraints list list.
738 * @param values the values
741 public static List<Constraint> createValidValuesConstraintsList(String... values) {
744 mdcDataDebugMessage.debugEntryMessage(null, null);
746 List<Constraint> constraints;
747 Constraint validValues;
748 constraints = new ArrayList<>();
749 validValues = DataModelUtil.createValidValuesConstraint(values);
750 constraints.add(validValues);
752 mdcDataDebugMessage.debugExitMessage(null, null);
757 * Create greater or equal constrain constraint.
759 * @param value the value
760 * @return the constraint
762 public static Constraint createGreaterOrEqualConstrain(Object value) {
763 mdcDataDebugMessage.debugEntryMessage(null, null);
765 Constraint constraint = new Constraint();
766 constraint.setGreater_or_equal(value);
768 mdcDataDebugMessage.debugExitMessage(null, null);
773 * Gets constrain list.
775 * @param constrains the constrains
776 * @return the constrain list
778 public static List<Constraint> getConstrainList(Constraint... constrains) {
779 return Arrays.asList(constrains);
784 * Create get input property value from list parameter map.
786 * @param inputPropertyListName the input property list name
787 * @param indexInTheList the index in the list
788 * @param nestedPropertyName the nested property name
791 public static Map createGetInputPropertyValueFromListParameter(String inputPropertyListName,
793 String... nestedPropertyName) {
796 mdcDataDebugMessage.debugEntryMessage(null, null);
798 List propertyList = new ArrayList<>();
799 propertyList.add(inputPropertyListName);
800 propertyList.add(indexInTheList);
801 if (nestedPropertyName != null) {
802 Collections.addAll(propertyList, nestedPropertyName);
804 Map getInputProperty = new HashMap<>();
805 getInputProperty.put(ToscaFunctions.GET_INPUT.getDisplayName(), propertyList);
807 mdcDataDebugMessage.debugExitMessage(null, null);
808 return getInputProperty;
812 * Convert property def to parameter def parameter definition ext.
814 * @param propertyDefinition the property definition
815 * @return the parameter definition ext
817 public static ParameterDefinitionExt convertPropertyDefToParameterDef(
818 PropertyDefinition propertyDefinition) {
821 mdcDataDebugMessage.debugEntryMessage(null, null);
823 if (propertyDefinition == null) {
827 ParameterDefinitionExt parameterDefinition = new ParameterDefinitionExt();
828 parameterDefinition.setType(propertyDefinition.getType());
829 parameterDefinition.setDescription(propertyDefinition.getDescription());
830 parameterDefinition.setRequired(propertyDefinition.getRequired());
831 parameterDefinition.set_default(propertyDefinition.get_default());
832 parameterDefinition.setStatus(propertyDefinition.getStatus());
833 parameterDefinition.setConstraints(propertyDefinition.getConstraints());
834 parameterDefinition.setEntry_schema(Objects.isNull(propertyDefinition.getEntry_schema()) ? null
835 : propertyDefinition.getEntry_schema().clone());
836 parameterDefinition.setHidden(false);
837 parameterDefinition.setImmutable(false);
839 mdcDataDebugMessage.debugExitMessage(null, null);
840 return parameterDefinition;
844 * Convert attribute def to parameter def parameter definition ext.
846 * @param attributeDefinition the attribute definition
847 * @param outputValue the output value
848 * @return the parameter definition ext
850 public static ParameterDefinitionExt convertAttributeDefToParameterDef(
851 AttributeDefinition attributeDefinition, Map<String, List> outputValue) {
854 mdcDataDebugMessage.debugEntryMessage(null, null);
856 if (attributeDefinition == null) {
859 ParameterDefinitionExt parameterDefinition = new ParameterDefinitionExt();
860 parameterDefinition.setDescription(attributeDefinition.getDescription());
861 parameterDefinition.setValue(outputValue);
863 mdcDataDebugMessage.debugExitMessage(null, null);
864 return parameterDefinition;
868 * Convert capability type to capability definition capability definition.
870 * @param capabilityTypeId the capability type id
871 * @param capabilityType the capability type
872 * @param properties the properties
873 * @return the capability definition
875 public static CapabilityDefinition convertCapabilityTypeToCapabilityDefinition(
876 String capabilityTypeId, CapabilityType capabilityType, Map<String, Object> properties) {
879 mdcDataDebugMessage.debugEntryMessage(null, null);
881 CapabilityDefinition capabilityDefinition = new CapabilityDefinition();
882 capabilityDefinition.setAttributes(cloneAttributeDefinitionMap(capabilityType.getAttributes()));
883 capabilityDefinition.setProperties(clonePropertyDefinitionMap(capabilityType.getProperties()));
884 capabilityDefinition.setDescription(capabilityType.getDescription());
885 capabilityDefinition.setType(capabilityTypeId);
887 capabilityDefinition.getProperties()
890 .filter(entry -> properties.containsKey(entry.getKey()))
891 .forEach(entry -> entry.getValue()
892 .set_default(properties.get(entry.getKey())));
894 mdcDataDebugMessage.debugExitMessage(null, null);
895 return capabilityDefinition;
899 * Clone property definition map map.
901 * @param propertyDefinitionMap the property definition map
904 public static Map clonePropertyDefinitionMap(
905 Map<String, PropertyDefinition> propertyDefinitionMap) {
908 mdcDataDebugMessage.debugEntryMessage(null, null);
910 Map outMap = new HashMap<>();
911 for (String propertyDefKey : propertyDefinitionMap.keySet()) {
912 PropertyDefinition propertyDefValue = propertyDefinitionMap.get(propertyDefKey);
913 outMap.put(new String(propertyDefKey), propertyDefValue.clone());
916 mdcDataDebugMessage.debugExitMessage(null, null);
921 * Clone attribute definition map map.
923 * @param attributeDefinitionMap the attribute definition map
926 public static Map cloneAttributeDefinitionMap(
927 Map<String, AttributeDefinition> attributeDefinitionMap) {
930 mdcDataDebugMessage.debugEntryMessage(null, null);
932 Map outMap = new HashMap<>();
933 for (String attributeDefKey : attributeDefinitionMap.keySet()) {
934 AttributeDefinition attributeDefinition = attributeDefinitionMap.get(attributeDefKey);
935 outMap.put(new String(attributeDefKey), attributeDefinition.clone());
938 mdcDataDebugMessage.debugExitMessage(null, null);
942 public static boolean isNodeTemplate(String entryId, ServiceTemplate serviceTemplate) {
943 return serviceTemplate.getTopology_template().getNode_templates() != null
944 && serviceTemplate.getTopology_template().getNode_templates().get(entryId) != null;
948 * Add Input parameter.
950 * @param serviceTemplate the service template
951 * @param parameterDefinitionId the parameter definition id
952 * @param parameterDefinition the parameter definition
954 public static void addInputParameterToTopologyTemplate(ServiceTemplate serviceTemplate,
955 String parameterDefinitionId,
956 ParameterDefinition parameterDefinition) {
959 mdcDataDebugMessage.debugEntryMessage(null, null);
961 if (Objects.isNull(serviceTemplate)) {
962 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
963 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
964 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
965 throw new CoreException(
966 new InvalidAddActionNullEntityErrorBuilder("Topology Template Input Parameter",
967 "Service Template").build());
969 TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
970 if (Objects.isNull(topologyTemplate)) {
971 topologyTemplate = new TopologyTemplate();
972 serviceTemplate.setTopology_template(topologyTemplate);
974 if (topologyTemplate.getInputs() == null) {
975 topologyTemplate.setInputs(new HashMap<>());
977 topologyTemplate.getInputs().put(parameterDefinitionId, parameterDefinition);
979 mdcDataDebugMessage.debugExitMessage(null, null);
984 * Add Output parameter.
986 * @param serviceTemplate the service template
987 * @param parameterDefinitionId the parameter definition id
988 * @param parameterDefinition the parameter definition
990 public static void addOutputParameterToTopologyTemplate(ServiceTemplate serviceTemplate,
991 String parameterDefinitionId,
992 ParameterDefinition parameterDefinition) {
995 mdcDataDebugMessage.debugEntryMessage(null, null);
997 if (Objects.isNull(serviceTemplate)) {
998 MdcDataErrorMessage.createErrorMessageAndUpdateMdc(LoggerConstants.TARGET_ENTITY_DB,
999 LoggerTragetServiceName.ADD_ENTITIES_TO_TOSCA, ErrorLevel.ERROR.name(),
1000 LoggerErrorCode.DATA_ERROR.getErrorCode(), LoggerErrorDescription.INVALID_ADD_ACTION);
1001 throw new CoreException(
1002 new InvalidAddActionNullEntityErrorBuilder("Topology Template Ouput Parameter",
1003 "Service Template").build());
1005 TopologyTemplate topologyTemplate = serviceTemplate.getTopology_template();
1006 if (Objects.isNull(topologyTemplate)) {
1007 topologyTemplate = new TopologyTemplate();
1008 serviceTemplate.setTopology_template(topologyTemplate);
1010 if (topologyTemplate.getOutputs() == null) {
1011 topologyTemplate.setOutputs(new HashMap<>());
1013 topologyTemplate.getOutputs().put(parameterDefinitionId, parameterDefinition);
1015 mdcDataDebugMessage.debugExitMessage(null, null);
1020 * Add requirement def to requirement def list.
1022 * @param requirementList requirement list
1023 * @param requirementDef added requirement def
1025 public static void addRequirementToList(List<Map<String, RequirementDefinition>> requirementList,
1026 Map<String, RequirementDefinition> requirementDef) {
1027 if (requirementDef == null) {
1030 if (requirementList == null) {
1031 requirementList = new ArrayList<Map<String, RequirementDefinition>>();
1034 for (Map.Entry<String, RequirementDefinition> entry : requirementDef.entrySet()) {
1035 CommonMethods.mergeEntryInList(entry.getKey(), entry.getValue(), requirementList);
1040 * get node template requirement.
1042 * @param nodeTemplate node template
1044 public static Map<String, RequirementAssignment> getNodeTemplateRequirements(
1045 NodeTemplate nodeTemplate) {
1046 mdcDataDebugMessage.debugEntryMessage(null, null);
1048 if (Objects.isNull(nodeTemplate)) {
1051 List<Map<String, RequirementAssignment>> templateRequirements = nodeTemplate.getRequirements();
1053 Map<String, RequirementAssignment> nodeTemplateRequirementsAssignment = new HashMap<>();
1054 if (CollectionUtils.isEmpty(templateRequirements)) {
1055 return nodeTemplateRequirementsAssignment;
1057 YamlUtil yamlUtil = new YamlUtil();
1058 for (Map<String, RequirementAssignment> requirementAssignmentMap : templateRequirements) {
1059 for (Map.Entry<String, RequirementAssignment> requirementEntry : requirementAssignmentMap
1061 RequirementAssignment requirementAssignment = (yamlUtil
1062 .yamlToObject(yamlUtil.objectToYaml(requirementEntry.getValue()),
1063 RequirementAssignment.class));
1064 nodeTemplateRequirementsAssignment
1065 .put(requirementEntry.getKey(), requirementAssignment);
1069 mdcDataDebugMessage.debugExitMessage(null, null);
1070 return nodeTemplateRequirementsAssignment;
1074 * Gets the list of requirements for the node template.
1076 * @param nodeTemplate the node template
1077 * @return the node template requirement list and null if the node has no requirements
1079 public static List<Map<String, RequirementAssignment>> getNodeTemplateRequirementList(
1080 NodeTemplate nodeTemplate) {
1081 mdcDataDebugMessage.debugEntryMessage(null, null);
1082 ToscaExtensionYamlUtil toscaExtensionYamlUtil = new ToscaExtensionYamlUtil();
1083 //Creating concrete objects
1084 List<Map<String, RequirementAssignment>> requirements = nodeTemplate.getRequirements();
1085 List<Map<String, RequirementAssignment>> concreteRequirementList = null;
1086 if (requirements != null) {
1087 concreteRequirementList = new ArrayList<>();
1088 ListIterator<Map<String, RequirementAssignment>> reqListIterator = requirements
1090 while (reqListIterator.hasNext()) {
1091 Map<String, RequirementAssignment> requirement = reqListIterator.next();
1092 Map<String, RequirementAssignment> concreteRequirement = new HashMap<>();
1093 for (Map.Entry<String, RequirementAssignment> reqEntry : requirement.entrySet()) {
1094 RequirementAssignment requirementAssignment = (toscaExtensionYamlUtil
1095 .yamlToObject(toscaExtensionYamlUtil.objectToYaml(reqEntry.getValue()),
1096 RequirementAssignment.class));
1097 concreteRequirement.put(reqEntry.getKey(), requirementAssignment);
1098 concreteRequirementList.add(concreteRequirement);
1099 reqListIterator.remove();
1102 requirements.clear();
1103 requirements.addAll(concreteRequirementList);
1104 nodeTemplate.setRequirements(requirements);
1106 mdcDataDebugMessage.debugExitMessage(null, null);
1107 return concreteRequirementList;
1111 * get requirement assignment from requirement assignment list by req key.
1113 * @param requirementsAssignmentList requirement defenition list
1114 * @param requirementKey requirement key
1116 public static Optional<List<RequirementAssignment>> getRequirementAssignment(
1117 List<Map<String, RequirementAssignment>> requirementsAssignmentList,
1118 String requirementKey) {
1120 mdcDataDebugMessage.debugEntryMessage(null, null);
1121 if (CollectionUtils.isEmpty(requirementsAssignmentList)) {
1122 return Optional.empty();
1125 List<RequirementAssignment> matchRequirementAssignmentList = new ArrayList<>();
1126 for (Map<String, RequirementAssignment> requirementMap : requirementsAssignmentList) {
1127 if (requirementMap.containsKey(requirementKey)) {
1128 YamlUtil yamlUtil = new YamlUtil();
1129 RequirementAssignment requirementAssignment = (yamlUtil
1130 .yamlToObject(yamlUtil.objectToYaml(requirementMap.get(requirementKey)),
1131 RequirementAssignment.class));
1132 matchRequirementAssignmentList.add(requirementAssignment);
1136 mdcDataDebugMessage.debugExitMessage(null, null);
1137 return Optional.ofNullable(matchRequirementAssignmentList);
1141 * remove requirement defenition from requirement defenition list by req key.
1143 * @param requirementsDefinitionList requirement defenition list
1144 * @param requirementKey requirement key
1146 public static void removeRequirementsDefinition(
1147 List<Map<String, RequirementDefinition>> requirementsDefinitionList,
1148 String requirementKey) {
1149 mdcDataDebugMessage.debugEntryMessage(null, null);
1150 if (requirementsDefinitionList == null) {
1154 List<Map<String, RequirementDefinition>> mapToBeRemoved = new ArrayList<>();
1155 for (Map<String, RequirementDefinition> reqMap : requirementsDefinitionList) {
1156 reqMap.remove(requirementKey);
1157 if (reqMap.isEmpty()) {
1158 mapToBeRemoved.add(reqMap);
1161 for (Map<String, RequirementDefinition> removeMap : mapToBeRemoved) {
1162 requirementsDefinitionList.remove(removeMap);
1165 mdcDataDebugMessage.debugExitMessage(null, null);
1169 * remove requirement assignment from requirement defenition list by req key.
1171 * @param requirementsAssignmentList requirement Assignment list
1172 * @param requirementKey requirement key
1174 public static void removeRequirementsAssignment(
1175 List<Map<String, RequirementAssignment>> requirementsAssignmentList,
1176 String requirementKey) {
1177 mdcDataDebugMessage.debugEntryMessage(null, null);
1178 if (requirementsAssignmentList == null) {
1182 List<Map<String, RequirementAssignment>> mapToBeRemoved = new ArrayList<>();
1183 for (Map<String, RequirementAssignment> reqMap : requirementsAssignmentList) {
1184 reqMap.remove(requirementKey);
1185 if (reqMap.isEmpty()) {
1186 mapToBeRemoved.add(reqMap);
1189 for (Map<String, RequirementAssignment> removeMap : mapToBeRemoved) {
1190 requirementsAssignmentList.remove(removeMap);
1193 mdcDataDebugMessage.debugExitMessage(null, null);
1198 * Remove requirement assignment.
1200 * @param nodeTemplate the node template
1201 * @param requirementKey the requirement key
1202 * @param requirementAssignmentToBeDeleted the requirement assignment to be deleted
1204 public static void removeRequirementAssignment(
1205 NodeTemplate nodeTemplate,
1206 String requirementKey,
1207 RequirementAssignment requirementAssignmentToBeDeleted) {
1208 mdcDataDebugMessage.debugEntryMessage(null, null);
1209 ToscaAnalyzerService toscaAnalyzerService = new ToscaAnalyzerServiceImpl();
1210 List<Map<String, RequirementAssignment>> nodeTemplateRequirements = nodeTemplate
1212 if (nodeTemplateRequirements == null) {
1216 Map<String, RequirementAssignment> mapToBeRemoved = new HashMap<>();
1217 ListIterator<Map<String, RequirementAssignment>> iter = nodeTemplateRequirements.listIterator();
1218 while (iter.hasNext()) {
1219 Map<String, RequirementAssignment> reqMap = iter.next();
1220 RequirementAssignment requirementAssignment = reqMap.get(requirementKey);
1221 if (requirementAssignment != null) {
1222 boolean isDesiredRequirementAssignment = toscaAnalyzerService
1223 .isDesiredRequirementAssignment(requirementAssignment,
1224 requirementAssignmentToBeDeleted.getCapability(),
1225 requirementAssignmentToBeDeleted.getNode(),
1226 requirementAssignmentToBeDeleted.getRelationship());
1227 if (isDesiredRequirementAssignment) {
1233 mdcDataDebugMessage.debugExitMessage(null, null);
1237 * Return the suffix of the input namespace
1238 * For an exmpale - for abc.sdf.vsrx, retrun vsrx
1240 * @param namespace namespace
1241 * @return String namespace suffix
1243 public static String getNamespaceSuffix(String namespace) {
1244 if (namespace == null) {
1247 String delimiterChar = ".";
1248 if (namespace.contains(delimiterChar)) {
1249 return namespace.substring(namespace.lastIndexOf(delimiterChar) + 1);
1255 * Return true if the input import exist in the input imports list.
1257 * @param imports namespace
1258 * @param importId namespace
1259 * @return true if exist, flase if not exist
1261 public static boolean isImportAddedToServiceTemplate(List<Map<String, Import>> imports,
1263 for (Map<String, Import> anImport : imports) {
1264 if (anImport.containsKey(importId)) {
1272 * Get output parameter according to the input outputParameterId.
1274 * @param serviceTemplate service template
1275 * @param outputParameterId output parameter id
1276 * @return ParameterDefinition - output parameter
1278 public static ParameterDefinition getOuputParameter(ServiceTemplate serviceTemplate,
1279 String outputParameterId) {
1280 mdcDataDebugMessage.debugEntryMessage(null, null);
1282 if (serviceTemplate == null
1283 || serviceTemplate.getTopology_template() == null
1284 || serviceTemplate.getTopology_template().getOutputs() == null) {
1288 mdcDataDebugMessage.debugExitMessage(null, null);
1289 return serviceTemplate.getTopology_template().getOutputs().get(outputParameterId);
1293 * Gets input parameters in a service template.
1295 * @param serviceTemplate the service template
1296 * @return the input parameters
1298 public static Map<String, ParameterDefinition> getInputParameters(ServiceTemplate
1300 if (serviceTemplate == null
1301 || serviceTemplate.getTopology_template() == null
1302 || serviceTemplate.getTopology_template().getInputs() == null) {
1305 return serviceTemplate.getTopology_template().getInputs();
1309 * Gets relationship templates in a service template.
1311 * @param serviceTemplate the service template
1312 * @return the relationship template
1314 public static Map<String, RelationshipTemplate> getRelationshipTemplates(ServiceTemplate
1316 if (serviceTemplate == null
1317 || serviceTemplate.getTopology_template() == null
1318 || serviceTemplate.getTopology_template().getRelationship_templates() == null) {
1321 return serviceTemplate.getTopology_template().getRelationship_templates();
1325 * Get property value according to the input propertyId.
1327 * @param nodeTemplate node template
1328 * @param propertyId property id
1329 * @return Object property Value
1331 public static Object getPropertyValue(NodeTemplate nodeTemplate,
1332 String propertyId) {
1333 mdcDataDebugMessage.debugEntryMessage(null, null);
1335 if (nodeTemplate == null
1336 || nodeTemplate.getProperties() == null) {
1340 mdcDataDebugMessage.debugExitMessage(null, null);
1341 return nodeTemplate.getProperties().get(propertyId);
1345 * Get node template properties according to the input node template id.
1347 * @param serviceTemplate service template
1348 * @param nodeTemplateId node template id
1349 * @return node template properties
1351 public static Map<String, Object> getNodeTemplateProperties(ServiceTemplate serviceTemplate,
1352 String nodeTemplateId) {
1353 mdcDataDebugMessage.debugEntryMessage(null, null);
1355 if (serviceTemplate == null
1356 || serviceTemplate.getTopology_template() == null
1357 || serviceTemplate.getTopology_template().getNode_templates() == null
1358 || serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId) == null) {
1362 mdcDataDebugMessage.debugExitMessage(null, null);
1363 return serviceTemplate.getTopology_template().getNode_templates().get(nodeTemplateId)
1368 * Compare two requirement assignment objects for equality.
1370 * @param first the first requirement assignement object
1371 * @param second the second requirement assignement object
1372 * @return true if objects are equal and false otherwise
1374 public static boolean compareRequirementAssignment(RequirementAssignment first,
1375 RequirementAssignment second) {
1376 if (first.getCapability().equals(second.getCapability())
1377 && first.getNode().equals(second.getNode())
1378 && first.getRelationship().equals(second.getRelationship())) {