1 package org.openecomp.sdc.validation.impl.validators;
3 import org.apache.commons.collections4.CollectionUtils;
4 import org.apache.commons.collections4.MapUtils;
5 import org.openecomp.core.validation.ErrorMessageCode;
6 import org.openecomp.core.validation.types.GlobalValidationContext;
7 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
8 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
9 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
10 import org.openecomp.sdc.heat.datatypes.model.Output;
11 import org.openecomp.sdc.heat.datatypes.model.Resource;
12 import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions;
13 import org.openecomp.sdc.heat.services.HeatStructureUtil;
14 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
15 import org.openecomp.sdc.logging.api.Logger;
16 import org.openecomp.sdc.logging.api.LoggerFactory;
17 import org.openecomp.sdc.validation.ValidationContext;
18 import org.openecomp.sdc.validation.base.ResourceBaseValidator;
19 import org.openecomp.sdc.validation.type.ConfigConstants;
20 import org.openecomp.sdc.validation.type.HeatResourceValidationContext;
21 import org.openecomp.sdc.validation.util.ValidationUtil;
23 import java.util.ArrayList;
24 import java.util.Collection;
25 import java.util.HashMap;
26 import java.util.HashSet;
27 import java.util.List;
29 import java.util.Objects;
32 public class HeatResourceValidator extends ResourceBaseValidator {
33 private static final Logger LOGGER = LoggerFactory.getLogger(ResourceBaseValidator.class);
34 private static final ErrorMessageCode ERROR_CODE_HTR_1 = new ErrorMessageCode("HTR1");
37 public void init(Map<String, Object> properties) {
38 super.init((Map<String, Object>) properties.get(ConfigConstants.Resource_Base_Validator));
42 public ValidationContext createValidationContext(String fileName,
44 HeatOrchestrationTemplate heatOrchestrationTemplate,
45 GlobalValidationContext globalContext) {
46 ManifestContent manifestContent = new ManifestContent();
48 manifestContent = ValidationUtil.validateManifest(globalContext);
49 } catch (Exception exception) {
50 LOGGER.debug("", exception);
52 Set<String> baseFiles = ManifestUtil.getBaseFiles(manifestContent);
53 String baseFileName = CollectionUtils.isEmpty(baseFiles) ? null : baseFiles.iterator().next();
54 globalContext.setMessageCode(ERROR_CODE_HTR_1);
55 HeatOrchestrationTemplate baseHot =
56 ValidationUtil.checkHeatOrchestrationPreCondition(baseFileName, globalContext);
57 Set<String> securityGroupsNamesFromBaseFileOutputs = baseFileName == null ? new HashSet<>()
58 : checkForBaseFilePortsExistenceAndReturnSecurityGroupNamesFromOutputsIfNot
61 Map<String, Resource> resourcesMap =
62 heatOrchestrationTemplate.getResources() == null ? new HashMap<>()
63 : heatOrchestrationTemplate.getResources();
65 Map<String, Output> outputMap = heatOrchestrationTemplate.getOutputs() == null ? new HashMap<>()
66 : heatOrchestrationTemplate.getOutputs();
68 Map<String, Map<String, Map<String, List<String>>>>
69 typeToPointingResourcesMap = new HashMap<>();
72 (fileName, resourcesMap, outputMap,
73 securityGroupsNamesFromBaseFileOutputs, typeToPointingResourcesMap, globalContext);
75 return new HeatResourceValidationContext
76 (heatOrchestrationTemplate, typeToPointingResourcesMap, envFileName);
79 private void initTypeRelationsMap(String fileName,
80 Map<String, Resource> resourceMap,
81 Map<String, Output> outputMap,
82 Set<String> securityGroupsNamesFromBaseFileOutputs,
83 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap,
84 GlobalValidationContext globalContext) {
86 initTypeRelationsMapFromResourcesMap
87 (fileName, resourceMap,
88 typeToPointingResourcesMap, globalContext);
90 initTypeRelationsMapFromOutputsMap
91 (fileName, resourceMap, outputMap,
92 typeToPointingResourcesMap, globalContext);
95 private void initTypeRelationsMapFromOutputsMap(String fileName,
96 Map<String, Resource> resourceMap,
97 Map<String, Output> outputMap,
98 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap,
99 GlobalValidationContext globalContext) {
100 for (Map.Entry<String, Output> outputEntry : outputMap.entrySet()) {
101 Object outputValue = outputEntry.getValue().getValue();
102 Set<String> referencedResources = HeatStructureUtil
103 .getReferencedValuesByFunctionName(fileName,
104 ResourceReferenceFunctions.GET_RESOURCE.getFunction(), outputValue, globalContext);
106 updateRelationsMapWithOutputsReferences
107 (outputEntry, resourceMap, referencedResources, typeToPointingResourcesMap);
113 private void updateRelationsMapWithOutputsReferences(Map.Entry<String, Output> outputEntry,
114 Map<String, Resource> resourceMap,
115 Set<String> referencedResources,
116 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap) {
118 for (String pointedResourceName : referencedResources) {
119 Resource pointedResource = resourceMap.get(pointedResourceName);
121 if (Objects.nonNull(pointedResource)) {
122 initCurrentResourceTypeInMap(pointedResourceName, pointedResource.getType(),
123 "output", typeToPointingResourcesMap);
125 typeToPointingResourcesMap
126 .get(pointedResource.getType()).get(pointedResourceName)
127 .get("output").add(outputEntry.getKey());
132 private void initTypeRelationsMapFromResourcesMap(String fileName,
133 Map<String, Resource> resourceMap,
134 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap,
135 GlobalValidationContext globalContext) {
136 for (Map.Entry<String, Resource> resourceEntry : resourceMap.entrySet()) {
137 Resource pointingResource = resourceEntry.getValue();
138 Map<String, Object> properties =
139 pointingResource.getProperties() == null ? new HashMap<>()
140 : pointingResource.getProperties();
142 Set<String> referencedResourcesByGetResource =
143 getResourcesIdsPointedByCurrentResource(fileName, ResourceReferenceFunctions.GET_RESOURCE,
144 properties, globalContext);
146 Set<String> referencedResourcesByGetAttr =
147 handleGetAttrBetweenResources(properties);
149 referencedResourcesByGetResource.addAll(referencedResourcesByGetAttr);
151 updateRelationsMapWithCurrentResourceReferences
152 (resourceMap, resourceEntry, referencedResourcesByGetResource,
153 typeToPointingResourcesMap);
157 private void updateRelationsMapWithSecurityGroupsFromBaseFileOutput(String fileName,
158 Map<String, Resource> resourcesMap,
159 Map.Entry<String, Resource> resourceEntry,
160 Map<String, Object> properties,
161 Set<String> securityGroupsNamesFromBaseFileOutputs,
162 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap,
163 GlobalValidationContext globalContext) {
165 Set<String> candidateSecurityGroupUsedFromBaseFile = getResourcesIdsPointedByCurrentResource
166 (fileName, ResourceReferenceFunctions.GET_PARAM, properties, globalContext);
167 removeNonSecurityGroupNamesFromList
168 (candidateSecurityGroupUsedFromBaseFile, securityGroupsNamesFromBaseFileOutputs);
170 for (String usedSecurityGroupId : candidateSecurityGroupUsedFromBaseFile) {
171 updateMapWithRelationsBetweenResources
172 (usedSecurityGroupId,
173 HeatResourcesTypes.NEUTRON_SECURITY_GROUP_RESOURCE_TYPE.getHeatResource(),
174 resourceEntry, typeToPointingResourcesMap);
179 private void removeNonSecurityGroupNamesFromList(
180 Set<String> candidateSecurityGroupUsedFromBaseFile,
181 Set<String> securityGroupsNamesFromBaseFileOutputs) {
183 Set<String> nonSecurityGroupNames = new HashSet<>();
184 for (String candidateSecurityGroup : candidateSecurityGroupUsedFromBaseFile) {
185 if (!securityGroupsNamesFromBaseFileOutputs.contains(candidateSecurityGroup)) {
186 nonSecurityGroupNames.add(candidateSecurityGroup);
190 candidateSecurityGroupUsedFromBaseFile.removeAll(nonSecurityGroupNames);
193 private void updateRelationsMapWithCurrentResourceReferences(Map<String, Resource> resourceMap,
194 Map.Entry<String, Resource> currentResourceEntry,
195 Set<String> referencedResourcesFromCurrentResource,
196 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap) {
198 for (String pointedResourceName : referencedResourcesFromCurrentResource) {
199 Resource pointedResource = resourceMap.get(pointedResourceName);
200 if (Objects.nonNull(pointedResource)) {
201 String pointedResourceType = pointedResource.getType();
203 updateMapWithRelationsBetweenResources
204 (pointedResourceName, pointedResourceType,
205 currentResourceEntry, typeToPointingResourcesMap);
210 private void updateMapWithRelationsBetweenResources(String pointedResourceName,
211 String pointedResourceType,
212 Map.Entry<String, Resource> currentResourceEntry,
213 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap) {
215 initCurrentResourceTypeInMap(pointedResourceName, pointedResourceType,
216 currentResourceEntry.getValue().getType(), typeToPointingResourcesMap);
218 typeToPointingResourcesMap.get(pointedResourceType).get(pointedResourceName).get
219 (currentResourceEntry.getValue().getType()).add(currentResourceEntry.getKey());
222 private void initCurrentResourceTypeInMap(String resourceName, String resourceType,
223 String pointingResourceType,
224 Map<String, Map<String, Map<String, List<String>>>> typeToPointingResourcesMap) {
226 typeToPointingResourcesMap.putIfAbsent(resourceType, new HashMap<>());
227 typeToPointingResourcesMap.get(resourceType).putIfAbsent(resourceName, new HashMap<>());
228 typeToPointingResourcesMap.get(resourceType).get(resourceName).putIfAbsent
229 (pointingResourceType, new ArrayList<>());
232 private Set<String> handleGetAttrBetweenResources(Map<String, Object> properties) {
233 Set<String> referencedResourcesByGetAttr = new HashSet<>();
234 for (Map.Entry<String, Object> proprtyEntry : properties.entrySet()) {
235 referencedResourcesByGetAttr.addAll(getGetAttrReferencesInCaseOfContrail(proprtyEntry
239 return referencedResourcesByGetAttr;
243 private Set<String> getGetAttrReferencesInCaseOfContrail(Object propertyValue) {
245 Set<String> getAttrReferences = new HashSet<>();
247 if (propertyValue instanceof Map) {
248 if (((Map) propertyValue).containsKey("get_attr")) {
249 value = ((Map) propertyValue).get("get_attr");
250 if (value instanceof List) {
251 if (((List) value).size() == 2 && ((List) value).get(1).equals("fq_name")) {
252 if (((List) value).get(0) instanceof String) {
253 getAttrReferences.add((String) ((List) value).get(0));
254 return getAttrReferences;
256 LOGGER.warn("invalid format of 'get_attr' function - " + propertyValue.toString());
261 Collection<Object> valCollection = ((Map) propertyValue).values();
262 for (Object entryValue : valCollection) {
263 getAttrReferences.addAll(getGetAttrReferencesInCaseOfContrail(entryValue));
266 } else if (propertyValue instanceof List) {
267 for (Object prop : (List) propertyValue) {
268 getAttrReferences.addAll(getGetAttrReferencesInCaseOfContrail(prop));
272 return getAttrReferences;
276 private Set<String> getResourcesIdsPointedByCurrentResource(String fileName,
277 ResourceReferenceFunctions function,
278 Map<String, Object> properties,
279 GlobalValidationContext globalContext) {
281 Set<String> referencedResources = new HashSet<>();
282 for (Map.Entry<String, Object> propertyEntry : properties.entrySet()) {
284 .addAll(HeatStructureUtil
285 .getReferencedValuesByFunctionName(fileName,
286 function.getFunction(),
287 propertyEntry.getValue(),
291 return referencedResources;
294 private Set<String> checkForBaseFilePortsExistenceAndReturnSecurityGroupNamesFromOutputsIfNot(
295 HeatOrchestrationTemplate heatOrchestrationTemplate) {
296 Set<String> securityGroupsNamesFromOutputsMap = new HashSet<>();
298 if (heatOrchestrationTemplate != null) {
299 Map<String, Resource> resourceMap = heatOrchestrationTemplate.getResources();
300 if (!isPortResourceExistInBaseFile(resourceMap)) {
301 getSecurityGroupsReferencedResourcesFromOutputs(securityGroupsNamesFromOutputsMap,
302 heatOrchestrationTemplate.getOutputs(), resourceMap);
305 return securityGroupsNamesFromOutputsMap;
308 private boolean isPortResourceExistInBaseFile(Map<String, Resource> resourceMap) {
309 for (Map.Entry<String, Resource> resourceEntry : resourceMap.entrySet()) {
310 if (resourceEntry.getValue().getType()
311 .equals(HeatResourcesTypes.NEUTRON_PORT_RESOURCE_TYPE.getHeatResource())) {
319 private void getSecurityGroupsReferencedResourcesFromOutputs(
320 Set<String> securityGroupsNamesFromOutputsMap, Map<String, Output> outputMap,
321 Map<String, Resource> resourceMap) {
323 if (MapUtils.isNotEmpty(outputMap)) {
324 for (Map.Entry<String, Output> outputEntry : outputMap.entrySet()) {
325 Object outputValue = outputEntry.getValue().getValue();
326 if (Objects.nonNull(outputValue) && outputValue instanceof Map) {
327 String resourceName = (String) ((Map) outputValue)
328 .get(ResourceReferenceFunctions.GET_RESOURCE.getFunction());
329 if (Objects.nonNull(resourceName)) {
330 Resource resource = resourceMap.get(resourceName);
331 if (Objects.nonNull(resource) && resource.getType().equals(
332 HeatResourcesTypes.NEUTRON_SECURITY_GROUP_RESOURCE_TYPE.getHeatResource())) {
333 securityGroupsNamesFromOutputsMap.add(outputEntry.getKey());