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=========================================================
19 * Modifications copyright (c) 2019 Nokia
20 * ================================================================================
22 package org.openecomp.sdc.be.components.csar;
24 import com.google.common.collect.Lists;
25 import com.google.common.collect.Maps;
26 import com.google.gson.Gson;
27 import fj.data.Either;
28 import java.util.Collections;
29 import java.util.EnumMap;
30 import java.util.Objects;
31 import org.apache.commons.collections.CollectionUtils;
32 import org.apache.commons.collections.MapUtils;
33 import org.apache.commons.lang.StringUtils;
34 import org.openecomp.sdc.be.components.impl.AnnotationBusinessLogic;
35 import org.openecomp.sdc.be.components.impl.GroupTypeBusinessLogic;
36 import org.openecomp.sdc.be.components.impl.ImportUtils;
37 import org.openecomp.sdc.be.components.impl.NodeFilterUploadCreator;
38 import org.openecomp.sdc.be.components.impl.PolicyTypeBusinessLogic;
39 import org.openecomp.sdc.be.components.impl.exceptions.ByActionStatusComponentException;
40 import org.openecomp.sdc.be.components.utils.PropertiesUtils;
41 import org.openecomp.sdc.be.config.BeEcompErrorManager;
42 import org.openecomp.sdc.be.dao.api.ActionStatus;
43 import org.openecomp.sdc.be.dao.jsongraph.JanusGraphDao;
44 import org.openecomp.sdc.be.datatypes.elements.CapabilityDataDefinition;
45 import org.openecomp.sdc.be.datatypes.elements.GetInputValueDataDefinition;
46 import org.openecomp.sdc.be.datatypes.elements.PolicyTargetType;
47 import org.openecomp.sdc.be.datatypes.elements.PropertyDataDefinition;
48 import org.openecomp.sdc.be.model.CapabilityDefinition;
49 import org.openecomp.sdc.be.model.ComponentInstanceProperty;
50 import org.openecomp.sdc.be.model.GroupDefinition;
51 import org.openecomp.sdc.be.model.GroupTypeDefinition;
52 import org.openecomp.sdc.be.model.InputDefinition;
53 import org.openecomp.sdc.be.model.NodeTypeInfo;
54 import org.openecomp.sdc.be.model.ParsedToscaYamlInfo;
55 import org.openecomp.sdc.be.model.PolicyDefinition;
56 import org.openecomp.sdc.be.model.PolicyTypeDefinition;
57 import org.openecomp.sdc.be.model.UploadArtifactInfo;
58 import org.openecomp.sdc.be.model.UploadCapInfo;
59 import org.openecomp.sdc.be.model.UploadComponentInstanceInfo;
60 import org.openecomp.sdc.be.model.UploadPropInfo;
61 import org.openecomp.sdc.be.model.UploadReqInfo;
62 import org.openecomp.sdc.be.model.tosca.ToscaPropertyType;
63 import org.openecomp.sdc.be.utils.TypeUtils;
64 import org.openecomp.sdc.common.log.wrappers.Logger;
65 import org.springframework.stereotype.Component;
66 import org.yaml.snakeyaml.parser.ParserException;
68 import java.util.ArrayList;
69 import java.util.Collection;
70 import java.util.HashMap;
71 import java.util.List;
74 import java.util.regex.Pattern;
75 import java.util.stream.Collectors;
77 import static java.util.stream.Collectors.toList;
78 import static org.openecomp.sdc.be.components.impl.ImportUtils.ResultStatusEnum;
79 import static org.openecomp.sdc.be.components.impl.ImportUtils.ToscaElementTypeEnum;
80 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaListElement;
81 import static org.openecomp.sdc.be.components.impl.ImportUtils.findFirstToscaMapElement;
82 import static org.openecomp.sdc.be.components.impl.ImportUtils.findToscaElement;
83 import static org.openecomp.sdc.be.components.impl.ImportUtils.loadYamlAsStrictMap;
84 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.ARTIFACTS;
85 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.CAPABILITIES;
86 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.CAPABILITY;
87 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DEFAULT_VALUE;
88 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.DESCRIPTION;
89 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.FILE;
90 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.GET_INPUT;
91 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.GROUPS;
92 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.IS_PASSWORD;
93 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.MEMBERS;
94 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NODE;
95 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.NODE_TEMPLATES;
96 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.POLICIES;
97 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.PROPERTIES;
98 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.REQUIREMENTS;
99 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.SUBSTITUTION_MAPPINGS;
100 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TARGETS;
101 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TOPOLOGY_TEMPLATE;
102 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.TYPE;
103 import static org.openecomp.sdc.be.utils.TypeUtils.ToscaTagNamesEnum.VALID_SOURCE_TYPES;
106 * A handler class designed to parse the YAML file of the service template for a JAVA object
109 public class YamlTemplateParsingHandler {
111 private static final Pattern propertyValuePattern = Pattern.compile("[ ]*\\{[ ]*(str_replace=|token=|get_property=|concat=|get_attribute=)+");
112 private static final int SUB_MAPPING_CAPABILITY_OWNER_NAME_IDX = 0;
113 private static final int SUB_MAPPING_CAPABILITY_NAME_IDX = 1;
114 private static final Logger log = Logger.getLogger(YamlTemplateParsingHandler.class);
117 private Gson gson = new Gson();
118 private JanusGraphDao janusGraphDao;
119 private GroupTypeBusinessLogic groupTypeBusinessLogic;
120 private AnnotationBusinessLogic annotationBusinessLogic;
121 private PolicyTypeBusinessLogic policyTypeBusinessLogic;
123 public YamlTemplateParsingHandler(JanusGraphDao janusGraphDao, GroupTypeBusinessLogic groupTypeBusinessLogic,
124 AnnotationBusinessLogic annotationBusinessLogic, PolicyTypeBusinessLogic policyTypeBusinessLogic) {
125 this.janusGraphDao = janusGraphDao;
126 this.groupTypeBusinessLogic = groupTypeBusinessLogic;
127 this.annotationBusinessLogic = annotationBusinessLogic;
128 this.policyTypeBusinessLogic = policyTypeBusinessLogic;
131 public ParsedToscaYamlInfo parseResourceInfoFromYAML(String fileName, String resourceYml, Map<String, String> createdNodesToscaResourceNames,
132 Map<String, NodeTypeInfo> nodeTypesInfo, String nodeName) {
133 log.debug("#parseResourceInfoFromYAML - Going to parse yaml {} ", fileName);
134 Map<String, Object> mappedToscaTemplate = getMappedToscaTemplate(fileName, resourceYml, nodeTypesInfo, nodeName);
135 ParsedToscaYamlInfo parsedToscaYamlInfo = new ParsedToscaYamlInfo();
136 findToscaElement(mappedToscaTemplate, TOPOLOGY_TEMPLATE, ToscaElementTypeEnum.ALL)
138 .on(err -> failIfNotTopologyTemplate(fileName));
140 parsedToscaYamlInfo.setInputs(getInputs(mappedToscaTemplate));
141 parsedToscaYamlInfo.setInstances(getInstances(fileName, mappedToscaTemplate, createdNodesToscaResourceNames));
142 parsedToscaYamlInfo.setGroups(getGroups(fileName, mappedToscaTemplate));
143 parsedToscaYamlInfo.setPolicies(getPolicies(fileName, mappedToscaTemplate));
144 log.debug("#parseResourceInfoFromYAML - The yaml {} has been parsed ", fileName);
145 return parsedToscaYamlInfo;
148 private Map<String, Object> getMappedToscaTemplate(String fileName, String resourceYml, Map<String, NodeTypeInfo> nodeTypesInfo, String nodeName) {
149 Map<String, Object> mappedToscaTemplate;
150 if (isNodeExist(nodeTypesInfo, nodeName)) {
151 mappedToscaTemplate = nodeTypesInfo.get(nodeName).getMappedToscaTemplate();
153 mappedToscaTemplate = loadYaml(fileName, resourceYml);
155 return mappedToscaTemplate;
158 private Map<String, Object> loadYaml(String fileName, String resourceYml) {
159 Map<String, Object> mappedToscaTemplate = null;
161 mappedToscaTemplate = loadYamlAsStrictMap(resourceYml);
162 } catch (ParserException e) {
163 log.debug("#getMappedToscaTemplate - Failed to load YAML file {}", fileName, e);
164 rollbackWithException(ActionStatus.TOSCA_PARSE_ERROR, fileName, e.getMessage());
166 return mappedToscaTemplate;
169 private boolean isNodeExist(Map<String, NodeTypeInfo> nodeTypesInfo, String nodeName) {
170 return nodeTypesInfo != null && nodeName != null && nodeTypesInfo.containsKey(nodeName);
173 private Map<String, InputDefinition> getInputs(Map<String, Object> toscaJson) {
174 Map<String, InputDefinition> inputs = ImportUtils.getInputs(toscaJson, annotationBusinessLogic.getAnnotationTypeOperations())
176 .on(err -> new HashMap<>());
177 annotationBusinessLogic.validateAndMergeAnnotationsAndAssignToInput(inputs);
181 private Map<String, PolicyDefinition> getPolicies(String fileName, Map<String, Object> toscaJson) {
183 Map<String, Object> foundPolicies = findFirstToscaMapElement(toscaJson, POLICIES)
185 .on(err -> logPoliciesNotFound(fileName));
187 if (MapUtils.isNotEmpty(foundPolicies)) {
191 .map(this::createPolicy)
192 .collect(Collectors.toMap(PolicyDefinition::getName, p -> p));
194 return Collections.emptyMap();
197 private PolicyDefinition createPolicy(Map.Entry<String, Object> policyNameValue) {
198 PolicyDefinition emptyPolicyDef = new PolicyDefinition();
199 String policyName = policyNameValue.getKey();
200 emptyPolicyDef.setName(policyName);
202 if (policyNameValue.getValue() != null && policyNameValue.getValue() instanceof Map) {
203 Map<String, Object> policyTemplateJsonMap = (Map<String, Object>) policyNameValue.getValue();
204 validateAndFillPolicy(emptyPolicyDef, policyTemplateJsonMap);
206 rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
208 } catch (ClassCastException e) {
209 log.debug("#createPolicy - Failed to create the policy {}. The exception occurred", policyName, e);
210 rollbackWithException(ActionStatus.INVALID_YAML);
212 return emptyPolicyDef;
215 private Map<String, Object> logPoliciesNotFound(String fileName) {
216 log.debug("#logPoliciesNotFound - Policies were not found in the yaml template {}.", fileName);
217 return Collections.emptyMap();
220 private void validateAndFillPolicy(PolicyDefinition emptyPolicyDefinition, Map<String, Object> policyTemplateJsonMap) {
221 String policyTypeName = (String) policyTemplateJsonMap.get(TYPE.getElementName());
222 if(StringUtils.isEmpty(policyTypeName)){
223 log.debug("#validateAndFillPolicy - The 'type' member is not found under policy {}", emptyPolicyDefinition.getName());
224 rollbackWithException(ActionStatus.POLICY_MISSING_POLICY_TYPE, emptyPolicyDefinition.getName());
226 emptyPolicyDefinition.setType(policyTypeName);
227 // set policy targets
228 emptyPolicyDefinition.setTargets(validateFillPolicyTargets(policyTemplateJsonMap));
229 PolicyTypeDefinition policyTypeDefinition = validateGetPolicyTypeDefinition(policyTypeName);
230 // set policy properties
231 emptyPolicyDefinition.setProperties(validateFillPolicyProperties(policyTypeDefinition, policyTemplateJsonMap));
234 private PolicyTypeDefinition validateGetPolicyTypeDefinition(String policyType) {
235 PolicyTypeDefinition policyTypeDefinition = policyTypeBusinessLogic.getLatestPolicyTypeByType(policyType);
236 if (policyTypeDefinition == null) {
237 log.debug("#validateAndFillPolicy - The policy type {} not found", policyType);
238 rollbackWithException(ActionStatus.POLICY_TYPE_IS_INVALID, policyType);
240 return policyTypeDefinition;
243 private List<PropertyDataDefinition> validateFillPolicyProperties(PolicyTypeDefinition policyTypeDefinition,
244 Map<String, Object> policyTemplateJsonMap) {
245 if (MapUtils.isEmpty(policyTemplateJsonMap) || Objects.isNull(policyTypeDefinition)) {
246 return Collections.emptyList();
248 List<PropertyDataDefinition> propertyDataDefinitionList = new ArrayList<>();
249 Map<String, Object> propertiesMap =
250 (Map<String, Object>) policyTemplateJsonMap.get(PROPERTIES.getElementName());
251 if (MapUtils.isEmpty(propertiesMap)) {
252 return Collections.emptyList();
254 if (CollectionUtils.isNotEmpty(policyTypeDefinition.getProperties())) {
255 propertyDataDefinitionList = policyTypeDefinition
258 .map(propertyDefinition -> setPropertyValue(propertiesMap,
260 .collect(Collectors.toList());
262 return propertyDataDefinitionList;
265 private PropertyDataDefinition setPropertyValue(Map<String, Object> propertiesMap, PropertyDataDefinition srcPropertyDataDefinition) {
266 PropertyDataDefinition newPropertyDef = new PropertyDataDefinition(srcPropertyDataDefinition);
267 String propertyName = newPropertyDef.getName();
268 if (Objects.nonNull(propertiesMap.get(propertyName))) {
269 Object propValue = propertiesMap.get(propertyName);
270 newPropertyDef.setValue(PropertiesUtils.trimQuotes(gson.toJson(propValue)));
272 return newPropertyDef;
275 private Map<PolicyTargetType, List<String>> validateFillPolicyTargets(Map<String, Object> policyTemplateJson) {
276 Map<PolicyTargetType, List<String>> targets = new EnumMap<>(PolicyTargetType.class);
277 if (policyTemplateJson.containsKey(TARGETS.getElementName())
278 && policyTemplateJson.get(TARGETS.getElementName()) instanceof List ) {
279 List<String> targetsElement = (List<String>) policyTemplateJson.get(TARGETS.getElementName());
280 targets.put(PolicyTargetType.COMPONENT_INSTANCES, targetsElement);
285 private Map<String, UploadComponentInstanceInfo> getInstances(String yamlName, Map<String, Object> toscaJson, Map<String, String> createdNodesToscaResourceNames) {
287 Map<String, Object> nodeTemlates = findFirstToscaMapElement(toscaJson, NODE_TEMPLATES)
289 .on(err -> failIfNoNodeTemplates(yamlName));
291 return getInstances(toscaJson, createdNodesToscaResourceNames, nodeTemlates);
294 private Map<String, UploadComponentInstanceInfo> getInstances(Map<String, Object> toscaJson, Map<String, String> createdNodesToscaResourceNames, Map<String, Object> nodeTemlates) {
295 Map<String, UploadComponentInstanceInfo> moduleComponentInstances;
296 Map<String, Object> substitutionMappings = getSubstitutionMappings(toscaJson);
297 moduleComponentInstances = nodeTemlates.entrySet()
299 .map(node -> buildModuleComponentInstanceInfo(node, substitutionMappings, createdNodesToscaResourceNames))
300 .collect(Collectors.toMap(UploadComponentInstanceInfo::getName, i -> i));
301 return moduleComponentInstances;
304 private Map<String, Object> getSubstitutionMappings(Map<String, Object> toscaJson) {
305 Map<String, Object> substitutionMappings = null;
306 Either<Map<String, Object>, ResultStatusEnum> eitherSubstitutionMappings = findFirstToscaMapElement(toscaJson, SUBSTITUTION_MAPPINGS);
307 if (eitherSubstitutionMappings.isLeft()) {
308 substitutionMappings = eitherSubstitutionMappings.left().value();
310 return substitutionMappings;
313 @SuppressWarnings("unchecked")
314 private Map<String, GroupDefinition> getGroups(String fileName, Map<String, Object> toscaJson) {
316 Map<String, Object> foundGroups = findFirstToscaMapElement(toscaJson, GROUPS)
318 .on(err -> logGroupsNotFound(fileName));
320 if (MapUtils.isNotEmpty(foundGroups)) {
321 Map<String, GroupDefinition> groups = foundGroups
324 .map(this::createGroup)
325 .collect(Collectors.toMap(GroupDefinition::getName, g -> g));
326 Map<String, Object> substitutionMappings = getSubstitutionMappings(toscaJson);
327 if (capabilitiesSubstitutionMappingsExist(substitutionMappings)) {
328 groups.entrySet().forEach(entry -> updateCapabilitiesNames(entry.getValue(), getNamesToUpdate(entry.getKey(),
329 (Map<String, List<String>>) substitutionMappings.get(CAPABILITIES.getElementName()))));
333 return new HashMap<>();
336 private Map<String, Object> logGroupsNotFound(String fileName) {
337 log.debug("#logGroupsNotFound - Groups were not found in the yaml template {}.", fileName);
338 return new HashMap<>();
341 private void updateCapabilitiesNames(GroupDefinition group, Map<String, String> capabilityNames) {
342 if (MapUtils.isNotEmpty(group.getCapabilities())) {
343 group.getCapabilities().values()
345 .flatMap(Collection::stream)
346 .filter(cap -> capabilityNames.containsKey(cap.getName()))
347 .forEach(cap -> cap.setName(capabilityNames.get(cap.getName())));
351 private Map<String, String> getNamesToUpdate(String name, Map<String, List<String>> pair) {
352 return pair.entrySet().stream()
353 .filter(e -> e.getValue().get(SUB_MAPPING_CAPABILITY_OWNER_NAME_IDX).equalsIgnoreCase(name))
354 .collect(Collectors.toMap(e -> e.getValue().get(SUB_MAPPING_CAPABILITY_NAME_IDX), Map.Entry::getKey, (n1 ,n2) -> n1));
357 private boolean capabilitiesSubstitutionMappingsExist(Map<String, Object> substitutionMappings) {
358 return substitutionMappings != null && substitutionMappings.containsKey(CAPABILITIES.getElementName());
361 private GroupDefinition createGroup(Map.Entry<String, Object> groupNameValue) {
362 GroupDefinition group = new GroupDefinition();
363 group.setName(groupNameValue.getKey());
365 if (groupNameValue.getValue() != null && groupNameValue.getValue() instanceof Map) {
366 Map<String, Object> groupTemplateJsonMap = (Map<String, Object>) groupNameValue.getValue();
367 validateAndFillGroup(group, groupTemplateJsonMap);
368 validateUpdateGroupProperties(group, groupTemplateJsonMap);
369 validateUpdateGroupCapabilities(group, groupTemplateJsonMap);
371 rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
373 } catch (ClassCastException e) {
374 log.debug("#createGroup - Failed to create the group {}. The exception occure", groupNameValue.getKey(), e);
375 rollbackWithException(ActionStatus.INVALID_YAML);
380 private Map<String, CapabilityDefinition> addCapabilities(Map<String, CapabilityDefinition> cap, Map<String, CapabilityDefinition> otherCap) {
381 cap.putAll(otherCap);
385 private Map<String, CapabilityDefinition> addCapability(CapabilityDefinition cap) {
386 Map<String, CapabilityDefinition> map = Maps.newHashMap();
387 map.put(cap.getName(), cap);
391 private void setMembers(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
392 if (groupTemplateJsonMap.containsKey(MEMBERS.getElementName())) {
393 Object members = groupTemplateJsonMap.get(MEMBERS.getElementName());
394 if (members != null) {
395 if (members instanceof List) {
396 setMembersFromList(groupInfo, (List<?>) members);
398 log.debug("The 'members' member is not of type list under group {}", groupInfo.getName());
399 rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
405 private void setMembersFromList(GroupDefinition groupInfo, List<?> membersAsList) {
406 groupInfo.setMembers(membersAsList
408 .collect(Collectors.toMap(Object::toString, member -> "")));
411 @SuppressWarnings("unchecked")
412 private void validateUpdateGroupProperties(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
413 if (groupTemplateJsonMap.containsKey(PROPERTIES.getElementName())) {
414 Object propertiesElement = groupTemplateJsonMap.get(PROPERTIES.getElementName());
415 if (propertiesElement instanceof Map){
416 mergeGroupProperties(groupInfo, (Map<String, Object>) propertiesElement);
421 private void mergeGroupProperties(GroupDefinition groupInfo, Map<String, Object> parsedProperties) {
422 if(CollectionUtils.isNotEmpty(groupInfo.getProperties())){
423 validateGroupProperties(parsedProperties, groupInfo);
424 groupInfo.getProperties().forEach(p -> mergeGroupProperty(p, parsedProperties));
428 private void mergeGroupProperty(PropertyDataDefinition property, Map<String, Object> parsedProperties) {
429 if(parsedProperties.containsKey(property.getName())){
430 Object propValue = parsedProperties.get(property.getName());
431 if (valueNotContainsPattern(propertyValuePattern, propValue)) {
432 setPropertyValueAndGetInputsValues(property, propValue);
437 private void setPropertyValueAndGetInputsValues(PropertyDataDefinition property, Object propValue) {
438 if(propValue != null){
439 UploadPropInfo uploadPropInfo = buildProperty(property.getName(), propValue);
440 property.setValue(convertPropertyValue(ToscaPropertyType.isValidType(property.getType()), uploadPropInfo.getValue()));
441 property.setGetInputValues(uploadPropInfo.getGet_input());
445 private String convertPropertyValue(ToscaPropertyType type, Object value) {
446 String convertedValue = null;
448 if (type == null || value instanceof Map || value instanceof List) {
449 convertedValue = gson.toJson(value);
451 convertedValue = value.toString();
454 return convertedValue;
457 private void setDescription(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
458 if (groupTemplateJsonMap.containsKey(DESCRIPTION.getElementName())) {
459 groupInfo.setDescription(
460 (String) groupTemplateJsonMap.get(DESCRIPTION.getElementName()));
464 private void validateAndFillGroup(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
465 String type = (String) groupTemplateJsonMap.get(TYPE.getElementName());
466 if(StringUtils.isEmpty(type)){
467 log.debug("#validateAndFillGroup - The 'type' member is not found under group {}", groupInfo.getName());
468 rollbackWithException(ActionStatus.GROUP_MISSING_GROUP_TYPE, groupInfo.getName());
470 groupInfo.setType(type);
471 GroupTypeDefinition groupType = groupTypeBusinessLogic.getLatestGroupTypeByType(type);
472 if (groupType == null) {
473 log.debug("#validateAndFillGroup - The group type {} not found", groupInfo.getName());
474 rollbackWithException(ActionStatus.GROUP_TYPE_IS_INVALID, type);
476 groupInfo.convertFromGroupProperties(groupType.getProperties());
477 groupInfo.convertCapabilityDefinitions(groupType.getCapabilities());
478 setDescription(groupInfo, groupTemplateJsonMap);
479 setMembers(groupInfo, groupTemplateJsonMap);
482 @SuppressWarnings("unchecked")
483 private void validateUpdateGroupCapabilities(GroupDefinition groupInfo, Map<String, Object> groupTemplateJsonMap) {
485 if (groupTemplateJsonMap.containsKey(CAPABILITIES.getElementName())) {
486 Object capabilities = groupTemplateJsonMap.get(CAPABILITIES.getElementName());
487 if (capabilities instanceof List) {
488 validateUpdateCapabilities(groupInfo, ((List<Object>) capabilities).stream()
489 .map(o -> buildGroupCapability(groupInfo, o))
490 .collect(Collectors.toMap(CapabilityDefinition::getType, this::addCapability, this::addCapabilities)));
491 } else if (capabilities instanceof Map) {
492 validateUpdateCapabilities(groupInfo, ((Map<String, Object>) capabilities).entrySet()
494 .map(e -> buildGroupCapability(groupInfo, e))
495 .collect(Collectors.toMap(CapabilityDefinition::getType, this::addCapability, this::addCapabilities)));
497 log.debug("#setCapabilities - Failed to import the capabilities of the group {}. ", groupInfo.getName());
498 rollbackWithException(ActionStatus.INVALID_YAML);
503 private void validateUpdateCapabilities(GroupDefinition groupInfo, Map<String, Map<String, CapabilityDefinition>> capabilityInfo) {
504 validateGroupCapabilities(groupInfo, capabilityInfo);
505 groupInfo.updateCapabilitiesProperties(capabilityInfo);
508 private void validateGroupCapabilities(GroupDefinition group, Map<String, Map<String, CapabilityDefinition>> parsedCapabilities) {
509 if (MapUtils.isNotEmpty(parsedCapabilities)) {
510 if (MapUtils.isEmpty(group.getCapabilities())) {
511 failOnMissingCapabilityTypes(group, Lists.newArrayList(parsedCapabilities.keySet()));
513 List<String> missingCapTypes = parsedCapabilities.keySet().stream().filter(ct -> !group.getCapabilities().containsKey(ct)).collect(toList());
514 if (CollectionUtils.isNotEmpty(missingCapTypes)) {
515 failOnMissingCapabilityTypes(group, missingCapTypes);
517 group.getCapabilities().entrySet().forEach(e -> validateCapabilities(group, e.getValue(), parsedCapabilities.get(e.getKey())));
521 private void validateCapabilities(GroupDefinition group, List<CapabilityDefinition> capabilities, Map<String, CapabilityDefinition> parsedCapabilities) {
522 List<String> allowedCapNames = capabilities.stream().map(CapabilityDefinition::getName).distinct().collect(toList());
523 List<String> missingCapNames = parsedCapabilities.keySet().stream().filter(c -> !allowedCapNames.contains(c)).collect(toList());
524 if (CollectionUtils.isNotEmpty(missingCapNames)) {
525 failOnMissingCapabilityNames(group, missingCapNames);
527 validateCapabilitiesProperties(capabilities, parsedCapabilities);
530 private void validateCapabilitiesProperties(List<CapabilityDefinition> capabilities, Map<String, CapabilityDefinition> parsedCapabilities) {
531 capabilities.forEach(c -> validateCapabilityProperties(c, parsedCapabilities.get(c.getName())));
534 private void validateCapabilityProperties(CapabilityDefinition capability, CapabilityDefinition parsedCapability) {
535 if(parsedCapability != null && parsedCapability.getProperties() != null){
536 List<String> parsedPropertiesNames = parsedCapability.getProperties()
538 .map(ComponentInstanceProperty::getName).collect(toList());
539 validateProperties(capability.getProperties().stream().map(PropertyDataDefinition::getName).collect(toList()), parsedPropertiesNames, ActionStatus.PROPERTY_NOT_FOUND, capability.getName(), capability.getType());
543 private void validateGroupProperties(Map<String, Object> parsedProperties, GroupDefinition groupInfo) {
544 List<String> parsedPropertiesNames = parsedProperties.entrySet()
546 .map(Map.Entry::getKey).collect(toList());
547 validateProperties(groupInfo.getProperties().stream().map(PropertyDataDefinition::getName).collect(toList()), parsedPropertiesNames, ActionStatus.GROUP_PROPERTY_NOT_FOUND, groupInfo.getName(), groupInfo.getType());
550 private void validateProperties(List<String> validProperties, List<String> parsedProperties, ActionStatus actionStatus, String name, String type) {
551 if (CollectionUtils.isNotEmpty(parsedProperties)) {
552 verifyMissingProperties(actionStatus, name, type, parsedProperties
554 .filter(n -> !validProperties.contains(n))
559 private void verifyMissingProperties(ActionStatus actionStatus, String name, String type, List<String> missingProperties) {
560 if (CollectionUtils.isNotEmpty(missingProperties)) {
561 log.debug("#validateProperties - Failed to validate properties. The properties {} are missing on {} of the type {}. ", missingProperties.toString(), name, type);
562 rollbackWithException(actionStatus, missingProperties.toString(), missingProperties.toString(), name, type);
566 @SuppressWarnings("unchecked")
567 private CapabilityDefinition buildGroupCapability(GroupDefinition groupInfo, Object capObject) {
568 if (!(capObject instanceof Map)) {
569 log.debug("#convertToGroupCapability - Failed to import the capability {}. ", capObject);
570 rollbackWithException(ActionStatus.INVALID_YAML);
572 return buildGroupCapability(groupInfo, ((Map<String, Object>) capObject).entrySet().iterator().next());
575 @SuppressWarnings("unchecked")
576 private CapabilityDefinition buildGroupCapability(GroupDefinition groupInfo, Map.Entry<String, Object> capEntry) {
577 CapabilityDefinition capability = new CapabilityDefinition();
578 capability.setOwnerType(CapabilityDataDefinition.OwnerType.GROUP);
579 capability.setName(capEntry.getKey());
580 capability.setParentName(capEntry.getKey());
581 capability.setOwnerId(groupInfo.getName());
582 if (!(capEntry.getValue() instanceof Map)) {
583 log.debug("#convertMapEntryToCapabilityDefinition - Failed to import the capability {}. ", capEntry.getKey());
584 rollbackWithException(ActionStatus.INVALID_YAML);
586 Map<String, Object> capabilityValue = (Map<String, Object>) capEntry.getValue();
587 String type = (String) capabilityValue.get(TYPE.getElementName());
588 if (StringUtils.isEmpty(type)) {
589 log.debug("#convertMapEntryToCapabilityDefinition - Failed to import the capability {}. Missing capability type. ", capEntry.getKey());
590 rollbackWithException(ActionStatus.INVALID_YAML);
592 capability.setType(type);
593 if (!(capabilityValue.get(PROPERTIES.getElementName()) instanceof Map)) {
594 log.debug("#convertMapEntryToCapabilityDefinition - Failed to import the capability {}. ", capEntry.getKey());
595 rollbackWithException(ActionStatus.INVALID_YAML);
597 Map<String, Object> properties = (Map<String, Object>) capabilityValue.get(PROPERTIES.getElementName());
598 capability.setProperties(properties.entrySet().stream().map(this::convertToProperty).collect(toList()));
602 private ComponentInstanceProperty convertToProperty(Map.Entry<String, Object> e) {
603 ComponentInstanceProperty property = new ComponentInstanceProperty();
604 property.setName(e.getKey());
605 property.setValue((String) e.getValue());
609 @SuppressWarnings("unchecked")
610 private UploadComponentInstanceInfo buildModuleComponentInstanceInfo(
611 Map.Entry<String, Object> nodeTemplateJsonEntry, Map<String, Object> substitutionMappings,
612 Map<String, String> createdNodesToscaResourceNames) {
614 UploadComponentInstanceInfo nodeTemplateInfo = new UploadComponentInstanceInfo();
615 nodeTemplateInfo.setName(nodeTemplateJsonEntry.getKey());
617 if (nodeTemplateJsonEntry.getValue() instanceof String) {
618 String nodeTemplateJsonString = (String) nodeTemplateJsonEntry.getValue();
619 nodeTemplateInfo.setType(nodeTemplateJsonString);
620 } else if (nodeTemplateJsonEntry.getValue() instanceof Map) {
621 Map<String, Object> nodeTemplateJsonMap = (Map<String, Object>) nodeTemplateJsonEntry.getValue();
622 setToscaResourceType(createdNodesToscaResourceNames, nodeTemplateInfo, nodeTemplateJsonMap);
623 setRequirements(nodeTemplateInfo, nodeTemplateJsonMap);
624 setCapabilities(nodeTemplateInfo, nodeTemplateJsonMap);
625 setArtifacts(nodeTemplateInfo, nodeTemplateJsonMap);
626 updateProperties(nodeTemplateInfo, nodeTemplateJsonMap);
627 setDirectives(nodeTemplateInfo, nodeTemplateJsonMap);
628 setNodeFilter(nodeTemplateInfo, nodeTemplateJsonMap);
629 setSubstitutions(substitutionMappings, nodeTemplateInfo);
631 rollbackWithException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE);
633 } catch (ClassCastException e) {
634 BeEcompErrorManager.getInstance().logBeSystemError("Import Resource - create capability");
635 log.debug("error when creating capability, message:{}", e.getMessage(), e);
636 rollbackWithException(ActionStatus.INVALID_YAML);
638 return nodeTemplateInfo;
641 @SuppressWarnings("unchecked")
642 private void setSubstitutions(Map<String, Object> substitutionMappings, UploadComponentInstanceInfo nodeTemplateInfo) {
643 if (substitutionMappings != null) {
644 if (substitutionMappings.containsKey(CAPABILITIES.getElementName())) {
645 nodeTemplateInfo.setCapabilitiesNamesToUpdate(getNamesToUpdate(nodeTemplateInfo.getName(), (Map<String, List<String>>) substitutionMappings
646 .get(CAPABILITIES.getElementName())));
648 if (substitutionMappings.containsKey(REQUIREMENTS.getElementName())) {
649 nodeTemplateInfo.setRequirementsNamesToUpdate(getNamesToUpdate(
650 nodeTemplateInfo.getName(), (Map<String, List<String>>) substitutionMappings
651 .get(REQUIREMENTS.getElementName())));
656 private void updateProperties(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
657 if (nodeTemplateJsonMap.containsKey(PROPERTIES.getElementName())) {
658 Map<String, List<UploadPropInfo>> properties = buildPropModuleFromYaml(nodeTemplateJsonMap);
659 if (!properties.isEmpty()) {
660 nodeTemplateInfo.setProperties(properties);
665 private void setCapabilities(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
666 if (nodeTemplateJsonMap.containsKey(CAPABILITIES.getElementName())) {
667 Map<String, List<UploadCapInfo>> eitherCapRes = createCapModuleFromYaml(nodeTemplateJsonMap);
668 if (!eitherCapRes.isEmpty()) {
669 nodeTemplateInfo.setCapabilities(eitherCapRes);
674 private void setArtifacts(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
675 if (nodeTemplateJsonMap.containsKey(ARTIFACTS.getElementName())) {
676 Map<String, Map<String, UploadArtifactInfo>> eitherArtifactsRes = createArtifactsModuleFromYaml(nodeTemplateJsonMap);
677 if (!eitherArtifactsRes.isEmpty()) {
678 nodeTemplateInfo.setArtifacts(eitherArtifactsRes);
683 private void setRequirements(UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
684 if (nodeTemplateJsonMap.containsKey(REQUIREMENTS.getElementName())) {
685 Map<String, List<UploadReqInfo>> regResponse = createReqModuleFromYaml(nodeTemplateJsonMap);
686 if (!regResponse.isEmpty()) {
687 nodeTemplateInfo.setRequirements(regResponse);
692 private void setToscaResourceType(Map<String, String> createdNodesToscaResourceNames,
693 UploadComponentInstanceInfo nodeTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
694 if (nodeTemplateJsonMap.containsKey(TYPE.getElementName())) {
695 String toscaResourceType = (String) nodeTemplateJsonMap.get(TYPE.getElementName());
696 if (createdNodesToscaResourceNames.containsKey(toscaResourceType)) {
697 toscaResourceType = createdNodesToscaResourceNames.get(toscaResourceType);
699 nodeTemplateInfo.setType(toscaResourceType);
703 private void setDirectives(UploadComponentInstanceInfo nodeTemplateInfo,
704 Map<String, Object> nodeTemplateJsonMap) {
705 List<String> directives =
706 (List<String>) nodeTemplateJsonMap.get(TypeUtils.ToscaTagNamesEnum.DIRECTIVES.getElementName());
707 nodeTemplateInfo.setDirectives(directives);
710 private void setNodeFilter(UploadComponentInstanceInfo nodeTemplateInfo,
711 Map<String, Object> nodeTemplateJsonMap) {
712 if (nodeTemplateJsonMap.containsKey(TypeUtils.ToscaTagNamesEnum.NODE_FILTER.getElementName())) {
713 nodeTemplateInfo.setUploadNodeFilterInfo(
714 new NodeFilterUploadCreator().createNodeFilterData(nodeTemplateJsonMap.get(
715 TypeUtils.ToscaTagNamesEnum.NODE_FILTER.getElementName())));
719 @SuppressWarnings("unchecked")
720 private Map<String, List<UploadReqInfo>> createReqModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
721 Map<String, List<UploadReqInfo>> moduleRequirements = new HashMap<>();
722 Either<List<Object>, ResultStatusEnum> requirementsListRes =
723 findFirstToscaListElement(nodeTemplateJsonMap, REQUIREMENTS);
725 if (requirementsListRes.isLeft()) {
726 for (Object jsonReqObj : requirementsListRes.left().value()) {
727 String reqName = ((Map<String, Object>) jsonReqObj).keySet().iterator().next();
728 Object reqJson = ((Map<String, Object>) jsonReqObj).get(reqName);
729 addModuleNodeTemplateReq(moduleRequirements, reqJson, reqName);
732 Either<Map<String, Object>, ResultStatusEnum> requirementsMapRes =
733 findFirstToscaMapElement(nodeTemplateJsonMap, REQUIREMENTS);
734 if (requirementsMapRes.isLeft()) {
735 for (Map.Entry<String, Object> entry : requirementsMapRes.left().value().entrySet()) {
736 String reqName = entry.getKey();
737 Object reqJson = entry.getValue();
738 addModuleNodeTemplateReq(moduleRequirements, reqJson, reqName);
742 return moduleRequirements;
745 private void addModuleNodeTemplateReq(Map<String, List<UploadReqInfo>> moduleRequirements, Object requirementJson, String requirementName) {
747 UploadReqInfo requirement = buildModuleNodeTemplateReg(requirementJson);
748 requirement.setName(requirementName);
749 if (moduleRequirements.containsKey(requirementName)) {
750 moduleRequirements.get(requirementName).add(requirement);
752 List<UploadReqInfo> list = new ArrayList<>();
753 list.add(requirement);
754 moduleRequirements.put(requirementName, list);
758 @SuppressWarnings("unchecked")
759 private Map<String, Map<String, UploadArtifactInfo>> createArtifactsModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
760 Map<String, Map<String, UploadArtifactInfo>> moduleArtifacts = new HashMap<>();
761 Either<List<Object>, ResultStatusEnum> ArtifactsListRes =
762 findFirstToscaListElement(nodeTemplateJsonMap, ARTIFACTS);
763 if (ArtifactsListRes.isLeft()) {
764 for (Object jsonArtifactObj : ArtifactsListRes.left().value()) {
765 String key = ((Map<String, Object>) jsonArtifactObj).keySet().iterator().next();
766 Object artifactJson = ((Map<String, Object>) jsonArtifactObj).get(key);
767 addModuleNodeTemplateArtifacts(moduleArtifacts, artifactJson, key);
770 Either<Map<String, Map<String, Object>>, ResultStatusEnum> ArtifactsMapRes =
771 findFirstToscaMapElement(nodeTemplateJsonMap, ARTIFACTS);
772 if (ArtifactsMapRes.isLeft()) {
773 for (Map.Entry<String, Map<String, Object>> entry : ArtifactsMapRes.left().value().entrySet()) {
774 String artifactName = entry.getKey();
775 Object artifactJson = entry.getValue();
776 addModuleNodeTemplateArtifacts(moduleArtifacts, artifactJson, artifactName);
780 return moduleArtifacts;
783 private void addModuleNodeTemplateArtifacts(Map<String, Map<String, UploadArtifactInfo>> moduleArtifacts, Object artifactJson, String artifactName) {
785 UploadArtifactInfo artifact = buildModuleNodeTemplateArtifact(artifactJson);
786 artifact.setName(artifactName);
787 if (moduleArtifacts.containsKey(ARTIFACTS.getElementName())) {
788 moduleArtifacts.get(ARTIFACTS.getElementName()).put(artifactName, artifact);
790 Map<String, UploadArtifactInfo> map = new HashMap<>();
791 map.put(artifactName, artifact);
792 moduleArtifacts.put(ARTIFACTS.getElementName(), map);
796 @SuppressWarnings("unchecked")
797 private UploadArtifactInfo buildModuleNodeTemplateArtifact(Object artifactObject) {
798 UploadArtifactInfo artifactTemplateInfo = new UploadArtifactInfo();
799 if (artifactObject instanceof Map) {
800 fillArtifact(artifactTemplateInfo, (Map<String, Object>) artifactObject);
802 return artifactTemplateInfo;
805 private void fillArtifact(UploadArtifactInfo artifactTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
806 if (nodeTemplateJsonMap.containsKey(TYPE.getElementName())) {
807 artifactTemplateInfo.setType((String) nodeTemplateJsonMap.get(TYPE.getElementName()));
809 if (nodeTemplateJsonMap.containsKey(FILE.getElementName())) {
810 artifactTemplateInfo.setFile((String) nodeTemplateJsonMap.get(FILE.getElementName()));
815 @SuppressWarnings("unchecked")
816 private Map<String, List<UploadCapInfo>> createCapModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
817 Map<String, List<UploadCapInfo>> moduleCap = new HashMap<>();
818 Either<List<Object>, ResultStatusEnum> capabilitiesListRes =
819 findFirstToscaListElement(nodeTemplateJsonMap, CAPABILITIES);
820 if (capabilitiesListRes.isLeft()) {
821 for (Object jsonCapObj : capabilitiesListRes.left().value()) {
822 String key = ((Map<String, Object>) jsonCapObj).keySet().iterator().next();
823 Object capJson = ((Map<String, Object>) jsonCapObj).get(key);
824 addModuleNodeTemplateCap(moduleCap, capJson, key);
827 Either<Map<String, Object>, ResultStatusEnum> capabilitiesMapRes =
828 findFirstToscaMapElement(nodeTemplateJsonMap, CAPABILITIES);
829 if (capabilitiesMapRes.isLeft()) {
830 for (Map.Entry<String, Object> entry : capabilitiesMapRes.left().value().entrySet()) {
831 String capName = entry.getKey();
832 Object capJson = entry.getValue();
833 addModuleNodeTemplateCap(moduleCap, capJson, capName);
840 private void addModuleNodeTemplateCap(Map<String, List<UploadCapInfo>> moduleCap, Object capJson, String key) {
842 UploadCapInfo capabilityDef = buildModuleNodeTemplateCap(capJson);
843 capabilityDef.setKey(key);
844 if (moduleCap.containsKey(key)) {
845 moduleCap.get(key).add(capabilityDef);
847 List<UploadCapInfo> list = new ArrayList<>();
848 list.add(capabilityDef);
849 moduleCap.put(key, list);
853 @SuppressWarnings("unchecked")
854 private UploadCapInfo buildModuleNodeTemplateCap(Object capObject) {
855 UploadCapInfo capTemplateInfo = new UploadCapInfo();
857 if (capObject instanceof String) {
858 String nodeTemplateJsonString = (String) capObject;
859 capTemplateInfo.setNode(nodeTemplateJsonString);
860 } else if (capObject instanceof Map) {
861 fillCapability(capTemplateInfo, (Map<String, Object>) capObject);
863 return capTemplateInfo;
866 private void fillCapability(UploadCapInfo capTemplateInfo, Map<String, Object> nodeTemplateJsonMap) {
867 if (nodeTemplateJsonMap.containsKey(NODE.getElementName())) {
868 capTemplateInfo.setNode((String) nodeTemplateJsonMap.get(NODE.getElementName()));
870 if (nodeTemplateJsonMap.containsKey(TYPE.getElementName())) {
871 capTemplateInfo.setType((String) nodeTemplateJsonMap.get(TYPE.getElementName()));
873 if (nodeTemplateJsonMap.containsKey(VALID_SOURCE_TYPES.getElementName())) {
874 Either<List<Object>, ResultStatusEnum> validSourceTypesRes =
875 findFirstToscaListElement(nodeTemplateJsonMap, VALID_SOURCE_TYPES);
876 if (validSourceTypesRes.isLeft()) {
877 capTemplateInfo.setValidSourceTypes(validSourceTypesRes.left().value().stream()
878 .map(Object::toString).collect(toList()));
881 if (nodeTemplateJsonMap.containsKey(PROPERTIES.getElementName())) {
882 Map<String, List<UploadPropInfo>> props = buildPropModuleFromYaml(nodeTemplateJsonMap);
883 if (!props.isEmpty()) {
884 List<UploadPropInfo> properties = props.values().stream().flatMap(Collection::stream).collect(toList());
885 capTemplateInfo.setProperties(properties);
890 @SuppressWarnings("unchecked")
891 private UploadReqInfo buildModuleNodeTemplateReg(Object regObject) {
893 UploadReqInfo regTemplateInfo = new UploadReqInfo();
894 if (regObject instanceof String) {
895 String nodeTemplateJsonString = (String) regObject;
896 regTemplateInfo.setNode(nodeTemplateJsonString);
897 } else if (regObject instanceof Map) {
898 Map<String, Object> nodeTemplateJsonMap = (Map<String, Object>) regObject;
899 if (nodeTemplateJsonMap.containsKey(NODE.getElementName())) {
900 regTemplateInfo.setNode((String) nodeTemplateJsonMap.get(NODE.getElementName()));
902 if (nodeTemplateJsonMap.containsKey(CAPABILITY.getElementName())) {
903 regTemplateInfo.setCapabilityName(
904 (String) nodeTemplateJsonMap.get(CAPABILITY.getElementName()));
907 return regTemplateInfo;
910 private Map<String, List<UploadPropInfo>> buildPropModuleFromYaml(Map<String, Object> nodeTemplateJsonMap) {
912 Map<String, List<UploadPropInfo>> moduleProp = new HashMap<>();
913 Either<Map<String, Object>, ResultStatusEnum> toscaProperties =
914 findFirstToscaMapElement(nodeTemplateJsonMap, PROPERTIES);
915 if (toscaProperties.isLeft()) {
916 Map<String, Object> jsonProperties = toscaProperties.left().value();
917 for (Map.Entry<String, Object> jsonPropObj : jsonProperties.entrySet()) {
918 if (valueNotContainsPattern(propertyValuePattern, jsonPropObj.getValue())) {
919 addProperty(moduleProp, jsonPropObj);
926 private void addProperty(Map<String, List<UploadPropInfo>> moduleProp, Map.Entry<String, Object> jsonPropObj) {
927 UploadPropInfo propertyDef = buildProperty(jsonPropObj.getKey(), jsonPropObj.getValue());
928 if (moduleProp.containsKey(propertyDef.getName())) {
929 moduleProp.get(propertyDef.getName()).add(propertyDef);
931 List<UploadPropInfo> list = new ArrayList<>();
932 list.add(propertyDef);
933 moduleProp.put(propertyDef.getName(), list);
937 @SuppressWarnings("unchecked")
938 private UploadPropInfo buildProperty(String propName, Object propValue) {
940 UploadPropInfo propertyDef = new UploadPropInfo();
941 propertyDef.setValue(propValue);
942 propertyDef.setName(propName);
943 if (propValue instanceof Map) {
944 if (((Map<String, Object>) propValue).containsKey(TYPE.getElementName())) {
945 propertyDef.setType(((Map<String, Object>) propValue)
946 .get(TYPE.getElementName()).toString());
948 if (containsGetInput(propValue)) {
949 fillInputRecursively(propName, (Map<String, Object>) propValue, propertyDef);
952 if (((Map<String, Object>) propValue).containsKey(DESCRIPTION.getElementName())) {
953 propertyDef.setDescription(((Map<String, Object>) propValue)
954 .get(DESCRIPTION.getElementName()).toString());
956 if (((Map<String, Object>) propValue)
957 .containsKey(DEFAULT_VALUE.getElementName())) {
958 propertyDef.setValue(((Map<String, Object>) propValue)
959 .get(DEFAULT_VALUE.getElementName()));
961 if (((Map<String, Object>) propValue).containsKey(IS_PASSWORD.getElementName())) {
962 propertyDef.setPassword(Boolean.getBoolean(((Map<String, Object>) propValue)
963 .get(IS_PASSWORD.getElementName()).toString()));
965 propertyDef.setValue(propValue);
967 } else if (propValue instanceof List) {
968 List<Object> propValueList = (List<Object>) propValue;
970 fillInputsListRecursively(propertyDef, propValueList);
971 propertyDef.setValue(propValue);
977 @SuppressWarnings("unchecked")
978 private boolean containsGetInput(Object propValue) {
979 return ((Map<String, Object>) propValue).containsKey(GET_INPUT.getElementName())
980 || ImportUtils.containsGetInput(propValue);
983 @SuppressWarnings("unchecked")
984 private void fillInputsListRecursively(UploadPropInfo propertyDef, List<Object> propValueList) {
985 for (Object objValue : propValueList) {
987 if (objValue instanceof Map) {
988 Map<String, Object> objMap = (Map<String, Object>) objValue;
989 if (objMap.containsKey(GET_INPUT.getElementName())) {
990 fillInputRecursively(propertyDef.getName(), objMap, propertyDef);
992 Set<String> keys = objMap.keySet();
993 findAndFillInputsListRecursively(propertyDef, objMap, keys);
995 } else if (objValue instanceof List) {
996 List<Object> propSubValueList = (List<Object>) objValue;
997 fillInputsListRecursively(propertyDef, propSubValueList);
1002 @SuppressWarnings("unchecked")
1003 private void findAndFillInputsListRecursively(UploadPropInfo propertyDef, Map<String, Object> objMap,
1005 for (String key : keys) {
1006 Object value = objMap.get(key);
1007 if (value instanceof Map) {
1008 fillInputRecursively(key, (Map<String, Object>) value, propertyDef);
1009 } else if (value instanceof List) {
1010 List<Object> propSubValueList = (List<Object>) value;
1011 fillInputsListRecursively(propertyDef, propSubValueList);
1016 private void fillInputRecursively(String propName, Map<String, Object> propValue, UploadPropInfo propertyDef) {
1018 if (propValue.containsKey(GET_INPUT.getElementName())) {
1019 Object getInput = propValue.get(GET_INPUT.getElementName());
1020 GetInputValueDataDefinition getInputInfo = new GetInputValueDataDefinition();
1021 List<GetInputValueDataDefinition> getInputs = propertyDef.getGet_input();
1022 if (getInputs == null) {
1023 getInputs = new ArrayList<>();
1025 if (getInput instanceof String) {
1027 getInputInfo.setInputName((String) getInput);
1028 getInputInfo.setPropName(propName);
1030 } else if (getInput instanceof List) {
1031 fillInput(propName, getInput, getInputInfo);
1033 getInputs.add(getInputInfo);
1034 propertyDef.setGet_input(getInputs);
1035 propertyDef.setValue(propValue);
1037 findAndFillInputRecursively(propValue, propertyDef);
1041 @SuppressWarnings("unchecked")
1042 private void findAndFillInputRecursively(Map<String, Object> propValue, UploadPropInfo propertyDef) {
1043 for (String propName : propValue.keySet()) {
1044 Object value = propValue.get(propName);
1045 if (value instanceof Map) {
1046 fillInputRecursively(propName, (Map<String, Object>) value, propertyDef);
1048 } else if (value instanceof List) {
1049 fillInputsRecursively(propertyDef, propName, (List<Object>) value);
1054 private void fillInputsRecursively(UploadPropInfo propertyDef, String propName, List<Object> inputs) {
1056 .filter(o -> o instanceof Map)
1057 .forEach(o -> fillInputRecursively(propName, (Map<String, Object>)o, propertyDef));
1060 @SuppressWarnings("unchecked")
1061 private void fillInput(String propName, Object getInput, GetInputValueDataDefinition getInputInfo) {
1062 List<Object> getInputList = (List<Object>) getInput;
1063 getInputInfo.setPropName(propName);
1064 getInputInfo.setInputName((String) getInputList.get(0));
1065 if (getInputList.size() > 1) {
1066 Object indexObj = getInputList.get(1);
1067 if (indexObj instanceof Integer) {
1068 getInputInfo.setIndexValue((Integer) indexObj);
1069 } else if (indexObj instanceof Float) {
1070 int index = ((Float) indexObj).intValue();
1071 getInputInfo.setIndexValue(index);
1072 } else if (indexObj instanceof Map && ((Map<String, Object>) indexObj)
1073 .containsKey(GET_INPUT.getElementName())) {
1074 Object index = ((Map<String, Object>) indexObj)
1075 .get(GET_INPUT.getElementName());
1076 GetInputValueDataDefinition getInputInfoIndex = new GetInputValueDataDefinition();
1077 getInputInfoIndex.setInputName((String) index);
1078 getInputInfoIndex.setPropName(propName);
1079 getInputInfo.setGetInputIndex(getInputInfoIndex);
1081 getInputInfo.setList(true);
1085 private boolean valueNotContainsPattern(Pattern pattern, Object propValue) {
1086 return propValue == null || !pattern.matcher(propValue.toString()).find();
1089 private Map<String, Object> failIfNoNodeTemplates(String fileName) {
1090 janusGraphDao.rollback();
1091 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, fileName);
1094 private Object failIfNotTopologyTemplate(String fileName) {
1095 janusGraphDao.rollback();
1096 throw new ByActionStatusComponentException(ActionStatus.NOT_TOPOLOGY_TOSCA_TEMPLATE, fileName);
1099 private void rollbackWithException(ActionStatus actionStatus, String... params) {
1100 janusGraphDao.rollback();
1101 throw new ByActionStatusComponentException(actionStatus, params);
1104 private void failOnMissingCapabilityTypes(GroupDefinition groupDefinition, List<String> missingCapTypes) {
1105 log.debug("#failOnMissingCapabilityTypes - Failed to validate the capabilities of the group {}. The capability types {} are missing on the group type {}. ", groupDefinition.getName(), missingCapTypes.toString(), groupDefinition.getType());
1106 if(CollectionUtils.isNotEmpty(missingCapTypes)) {
1107 rollbackWithException(ActionStatus.MISSING_CAPABILITY_TYPE, missingCapTypes.toString());
1111 private void failOnMissingCapabilityNames(GroupDefinition groupDefinition, List<String> missingCapNames) {
1112 log.debug("#failOnMissingCapabilityNames - Failed to validate the capabilities of the group {}. The capabilities with the names {} are missing on the group type {}. ", groupDefinition.getName(), missingCapNames.toString(), groupDefinition.getType());
1113 rollbackWithException(ActionStatus.MISSING_CAPABILITIES, missingCapNames.toString(), CapabilityDataDefinition.OwnerType.GROUP.getValue(), groupDefinition.getName());