2 * Copyright © 2016-2017 European Support Limited
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
8 * http://www.apache.org/licenses/LICENSE-2.0
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
17 package org.openecomp.sdc.validation.impl.validators;
19 import java.io.InputStream;
20 import java.util.Collection;
21 import java.util.HashSet;
22 import java.util.List;
24 import java.util.Objects;
25 import java.util.Optional;
28 import org.apache.commons.collections4.CollectionUtils;
29 import org.apache.commons.collections4.MapUtils;
30 import org.onap.sdc.tosca.services.YamlUtil;
31 import org.openecomp.core.validation.ErrorMessageCode;
32 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
33 import org.openecomp.core.validation.types.GlobalValidationContext;
34 import org.openecomp.sdc.common.errors.Messages;
35 import org.openecomp.sdc.datatypes.error.ErrorLevel;
36 import org.openecomp.sdc.heat.datatypes.DefinedHeatParameterTypes;
37 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
38 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
39 import org.openecomp.sdc.heat.datatypes.model.Environment;
40 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
41 import org.openecomp.sdc.heat.datatypes.model.HeatPseudoParameters;
42 import org.openecomp.sdc.heat.datatypes.model.HeatResourcesTypes;
43 import org.openecomp.sdc.heat.datatypes.model.Output;
44 import org.openecomp.sdc.heat.datatypes.model.Parameter;
45 import org.openecomp.sdc.heat.datatypes.model.Resource;
46 import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions;
47 import org.openecomp.sdc.heat.services.HeatStructureUtil;
48 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
49 import org.openecomp.sdc.logging.api.Logger;
50 import org.openecomp.sdc.logging.api.LoggerFactory;
51 import org.openecomp.sdc.validation.Validator;
52 import org.openecomp.sdc.validation.impl.util.HeatValidationService;
53 import org.openecomp.sdc.validation.util.ValidationUtil;
55 public class HeatValidator implements Validator {
56 private static final Logger LOGGER = LoggerFactory.getLogger(HeatValidator.class);
57 private static final ErrorMessageCode ERROR_CODE_HOT_1 = new ErrorMessageCode("HOT1");
58 private static final ErrorMessageCode ERROR_CODE_HOT_2 = new ErrorMessageCode("HOT2");
59 private static final ErrorMessageCode ERROR_CODE_HOT_3 = new ErrorMessageCode("HOT3");
60 private static final ErrorMessageCode ERROR_CODE_HOT_4 = new ErrorMessageCode("HOT4");
61 private static final ErrorMessageCode ERROR_CODE_HOT_5 = new ErrorMessageCode("HOT5");
62 private static final ErrorMessageCode ERROR_CODE_HOT_6 = new ErrorMessageCode("HOT6");
63 private static final ErrorMessageCode ERROR_CODE_HOT_7 = new ErrorMessageCode("HOT7");
64 private static final ErrorMessageCode ERROR_CODE_HOT_8 = new ErrorMessageCode("HOT8");
65 private static final ErrorMessageCode ERROR_CODE_HOT_9 = new ErrorMessageCode("HOT9");
66 private static final ErrorMessageCode ERROR_CODE_HOT_10 = new ErrorMessageCode("HOT10");
67 private static final ErrorMessageCode ERROR_CODE_HOT_11 = new ErrorMessageCode("HOT11");
68 private static final ErrorMessageCode ERROR_CODE_HOT_12 = new ErrorMessageCode("HOT12");
69 private static final ErrorMessageCode ERROR_CODE_HOT_13 = new ErrorMessageCode("HOT13");
70 private static final ErrorMessageCode ERROR_CODE_HOT_14 = new ErrorMessageCode("HOT14");
71 private static final ErrorMessageCode ERROR_CODE_HOT_15 = new ErrorMessageCode("HOT15");
72 private static final ErrorMessageCode ERROR_CODE_HOT_16 = new ErrorMessageCode("HOT16");
73 private static final ErrorMessageCode ERROR_CODE_HOT_17 = new ErrorMessageCode("HOT17");
75 private static void validateAllRequiredArtifactsExist(String fileName,
76 HeatOrchestrationTemplate
77 heatOrchestrationTemplate,
78 Set<String> artifacts,
79 GlobalValidationContext globalContext) {
80 Collection<Resource> resourcesValues = heatOrchestrationTemplate.getResources() == null ? null
81 : heatOrchestrationTemplate.getResources().values();
83 if (CollectionUtils.isNotEmpty(resourcesValues)) {
84 for (Resource resource : resourcesValues) {
85 Collection<Object> properties =
86 resource.getProperties() == null ? null : resource.getProperties().values();
87 validatePropertiesForAllRequiredArtifactsExist(properties, fileName,
88 artifacts, globalContext);
93 private static void validatePropertiesForAllRequiredArtifactsExist(Collection<Object> properties,
95 Set<String> artifacts,
96 GlobalValidationContext globalContext) {
97 if (CollectionUtils.isNotEmpty(properties)) {
98 for (Object property : properties) {
99 if (property instanceof Map) {
100 globalContext.setMessageCode(ERROR_CODE_HOT_14);
101 Set<String> artifactNames = HeatStructureUtil
102 .getReferencedValuesByFunctionName(fileName,
103 ResourceReferenceFunctions.GET_FILE.getFunction(), property, globalContext);
104 artifacts.addAll(artifactNames);
105 globalContext.setMessageCode(ERROR_CODE_HOT_15);
106 HeatValidationService.checkArtifactsExistence(fileName, artifactNames,
114 private static void validateAllResourceReferencesExist(String fileName,
115 HeatOrchestrationTemplate
116 heatOrchestrationTemplate,
117 GlobalValidationContext globalContext) {
118 Set<String> resourcesNames = heatOrchestrationTemplate.getResources() == null ? null
119 : heatOrchestrationTemplate.getResources().keySet();
120 Collection<Resource> resourcesValues = heatOrchestrationTemplate.getResources() == null ? null
121 : heatOrchestrationTemplate.getResources().values();
122 Collection<Output> outputsValues = heatOrchestrationTemplate.getOutputs() == null ? null
123 : heatOrchestrationTemplate.getOutputs().values();
124 checkResourceExistenceFromResourcesMap(fileName, resourcesNames, resourcesValues,
126 checkResourceExistenceFromResourcesMap(fileName, resourcesNames, outputsValues,
130 private static void checkResourceExistenceFromResourcesMap(String fileName,
131 Set<String> resourcesNames,
132 Collection<?> valuesToSearchIn,
133 GlobalValidationContext globalContext) {
134 if (CollectionUtils.isNotEmpty(valuesToSearchIn)) {
135 for (Object value : valuesToSearchIn) {
136 if (value instanceof Resource) {
137 extractResourceProperty(fileName, resourcesNames, globalContext,
139 } else if (value instanceof Output) {
140 Output output = (Output) value;
141 Object outputsValue = output.getValue();
142 handleReferencedResources(fileName, outputsValue, resourcesNames,
149 private static void extractResourceProperty(String fileName, Set<String> resourcesNames,
150 GlobalValidationContext globalContext,
152 Collection<Object> resourcePropertiesValues =
153 value.getProperties() == null ? null : value.getProperties()
155 if (CollectionUtils.isNotEmpty(resourcePropertiesValues)) {
156 for (Object propertyValue : resourcePropertiesValues) {
157 handleReferencedResources(fileName, propertyValue, resourcesNames,
163 private static void handleReferencedResources(String fileName, Object valueToSearchReferencesIn,
164 Set<String> resourcesNames,
165 GlobalValidationContext globalContext) {
166 globalContext.setMessageCode(ERROR_CODE_HOT_13);
167 Set<String> referencedResourcesNames = HeatStructureUtil
168 .getReferencedValuesByFunctionName(fileName,
169 ResourceReferenceFunctions.GET_RESOURCE.getFunction(),
170 valueToSearchReferencesIn, globalContext);
171 if (CollectionUtils.isNotEmpty(referencedResourcesNames)) {
172 checkIfResourceReferenceExist(fileName, resourcesNames, referencedResourcesNames,
177 private static void checkIfResourceReferenceExist(String fileName,
178 Set<String> referencedResourcesNames,
179 Set<String> referencedResources,
180 GlobalValidationContext globalContext) {
181 referencedResources.stream()
182 .filter(referencedResource -> !referencedResourcesNames
183 .contains(referencedResource))
184 .forEach(referencedResource ->
185 globalContext.addMessage(fileName,
186 ErrorLevel.ERROR, ErrorMessagesFormatBuilder
187 .getErrorWithParameters(ERROR_CODE_HOT_16,Messages
188 .REFERENCED_RESOURCE_NOT_FOUND.getErrorMessage(), referencedResource)));
193 private static void validateGetParamPointToParameter(String fileName,
194 HeatOrchestrationTemplate
195 heatOrchestrationTemplate,
196 GlobalValidationContext globalContext) {
197 Set<String> parametersNames = heatOrchestrationTemplate.getParameters() == null ? null
198 : heatOrchestrationTemplate.getParameters().keySet();
199 Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
201 if (CollectionUtils.isNotEmpty(parametersNames) && MapUtils.isNotEmpty(resourcesMap)) {
202 for (Map.Entry<String, Resource> resourceEntry : resourcesMap.entrySet()) {
203 Resource resource = resourceEntry.getValue();
204 Map<String, Object> properties = resource.getProperties();
205 validatePropertiesForGetParamPointToParameter(properties, fileName, parametersNames,
206 resourceEntry, globalContext);
211 private static void validatePropertiesForGetParamPointToParameter(Map<String,
213 String fileName, Set<String> parametersNames,
214 Map.Entry<String, Resource> resourceEntry,
215 GlobalValidationContext globalContext) {
216 if (MapUtils.isNotEmpty(properties)) {
217 Collection<Object> propertiesValues = properties.values();
218 if (CollectionUtils.isNotEmpty(propertiesValues)) {
219 for (Object propertyObject : propertiesValues) {
220 Set<String> referencedParameterNames = HeatStructureUtil
221 .getReferencedValuesByFunctionName(fileName, "get_param", propertyObject,
224 validateReferenceParams(fileName, resourceEntry.getKey(), parametersNames,
225 referencedParameterNames, globalContext);
231 private static void validateReferenceParams(String fileName, String resourceName,
232 Set<String> parametersNamesFromFile,
233 Set<String> referencedParametersNames,
234 GlobalValidationContext globalContext) {
235 for (String parameterName : referencedParametersNames) {
236 if (!isHeatPseudoParameter(parameterName)
237 && !parametersNamesFromFile.contains(parameterName)) {
238 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
239 .getErrorWithParameters(ERROR_CODE_HOT_1,Messages
240 .REFERENCED_PARAMETER_NOT_FOUND.getErrorMessage(),
241 parameterName, resourceName));
246 private static boolean isHeatPseudoParameter(String parameterName) {
247 return HeatPseudoParameters.getPseudoParameterNames().contains(parameterName);
252 private static void validateGetAttr(String fileName,
253 HeatOrchestrationTemplate heatOrchestrationTemplate,
254 GlobalValidationContext globalContext) {
255 Map<String, Output> outputMap;
256 outputMap = heatOrchestrationTemplate.getOutputs();
258 if (MapUtils.isNotEmpty(outputMap)) {
259 loopOverOutputMapAndValidateGetAttrFromNested(fileName, outputMap,
260 heatOrchestrationTemplate, globalContext);
264 private static void loopOverOutputMapAndValidateGetAttrFromNested(String fileName,
265 Map<String, Output> outputMap,
266 HeatOrchestrationTemplate
267 heatOrchestrationTemplate,
268 GlobalValidationContext
270 for (Output output : outputMap.values()) {
271 Object outputValue = output.getValue();
272 if (outputValue != null && outputValue instanceof Map) {
273 Map<String, Object> outputValueMap = (Map<String, Object>) outputValue;
274 List<String> getAttrValue =
275 (List<String>) outputValueMap.get(
276 ResourceReferenceFunctions.GET_ATTR.getFunction());
277 handleGetAttrValueList(getAttrValue, fileName, heatOrchestrationTemplate,
284 private static void handleGetAttrValueList(List<String> getAttrValue, String fileName,
285 HeatOrchestrationTemplate heatOrchestrationTemplate,
286 GlobalValidationContext globalContext) {
287 if (!CollectionUtils.isEmpty(getAttrValue)) {
288 String resourceName = getAttrValue.get(0);
289 String attNameObject = getAttrValue.get(1);
290 if (attNameObject == null) {
293 String attName = getAttrValue.get(1);
294 String resourceType =
295 getResourceTypeFromResourcesMap(resourceName, heatOrchestrationTemplate);
297 if (Objects.nonNull(resourceType)
298 && HeatValidationService.isNestedResource(resourceType)) {
299 handleGetAttrNestedResource(fileName, globalContext, resourceName, attName,
304 private static void handleGetAttrNestedResource(String fileName,
305 GlobalValidationContext globalContext,
306 String resourceName, String attName,
307 String resourceType) {
308 Map<String, Output> nestedOutputMap;
309 HeatOrchestrationTemplate nestedHeatOrchestrationTemplate;
311 Optional<InputStream> fileContent = globalContext.getFileContent(resourceType);
312 if (fileContent.isPresent()) {
313 nestedHeatOrchestrationTemplate =
314 new YamlUtil().yamlToObject(fileContent.get(), HeatOrchestrationTemplate.class);
316 throw new Exception("The file '" + resourceType + "' has no content");
318 } catch (Exception exception) {
319 LOGGER.error("Invalid yaml file", exception);
322 nestedOutputMap = nestedHeatOrchestrationTemplate.getOutputs();
324 if (MapUtils.isEmpty(nestedOutputMap) || !nestedOutputMap.containsKey(attName)) {
325 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
326 .getErrorWithParameters(ERROR_CODE_HOT_17,Messages
327 .GET_ATTR_NOT_FOUND.getErrorMessage(),
328 attName, resourceName));
332 private static String getResourceTypeFromResourcesMap(String resourceName,
333 HeatOrchestrationTemplate
334 heatOrchestrationTemplate) {
335 Resource resource = heatOrchestrationTemplate.getResources().get(resourceName);
336 if (Objects.nonNull(resource)) {
337 return resource.getType();
343 /* validation 17 + */
344 private static void validateEnvFile(String fileName, String envFileName,
345 HeatOrchestrationTemplate heatOrchestrationTemplate,
346 GlobalValidationContext globalContext) {
347 Environment envContent;
349 if (!envFileName.contains(".env")) {
350 globalContext.addMessage(envFileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
351 .getErrorWithParameters(ERROR_CODE_HOT_2,Messages
352 .WRONG_ENV_FILE_EXTENSION.getErrorMessage(), envFileName));
355 envContent = HeatValidationService.validateEnvContent(fileName, envFileName, globalContext);
356 if (envContent != null) {
357 validateEnvContentIsSubSetOfHeatParameters(envFileName, envContent, globalContext,
358 heatOrchestrationTemplate);
359 validateEnvParametersMatchDefinedHeatParameterTypes(envFileName, envContent, globalContext,
360 heatOrchestrationTemplate);
364 private static void validateEnvContentIsSubSetOfHeatParameters(String envFile,
365 Environment envContent,
366 GlobalValidationContext
368 HeatOrchestrationTemplate
369 heatOrchestrationTemplate) {
370 Set<String> parametersNames = heatOrchestrationTemplate.getParameters() == null ? null
371 : heatOrchestrationTemplate.getParameters().keySet();
373 if (MapUtils.isNotEmpty(envContent.getParameters())) {
374 if (CollectionUtils.isNotEmpty(parametersNames)) {
375 for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
378 validateEnvEntryForvalidateEnvContentIsSubSetOfHeatParameters(envEntry,
379 parametersNames, envFile, globalContext);
382 for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
383 globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
384 .getErrorWithParameters(ERROR_CODE_HOT_3,Messages
385 .ENV_INCLUDES_PARAMETER_NOT_IN_HEAT.getErrorMessage(),
386 envFile, envEntry.getKey()));
392 private static void validateEnvEntryForvalidateEnvContentIsSubSetOfHeatParameters(
393 Map.Entry<String, Object> envEntry,
394 Set<String> parametersNames,
396 GlobalValidationContext globalContext) {
397 String envParameter = envEntry.getKey();
398 if (parametersNames != null && !parametersNames.contains(envParameter)) {
399 globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
400 .getErrorWithParameters(
401 ERROR_CODE_HOT_3,Messages
402 .ENV_INCLUDES_PARAMETER_NOT_IN_HEAT.getErrorMessage(), envFile,
406 private static void validateParameterDefaultTypeAlignWithType(String fileName,
407 HeatOrchestrationTemplate
408 heatOrchestrationTemplate,
409 GlobalValidationContext
411 Map<String, Parameter> parametersMap = heatOrchestrationTemplate.getParameters();
413 if (parametersMap != null && MapUtils.isNotEmpty(parametersMap)) {
414 for (Map.Entry<String, Parameter> parameterEntry : parametersMap.entrySet()) {
415 validateParameterEntryForParameterDefaultTypeAlignWithType(parameterEntry,
416 fileName, globalContext);
420 private static void validateParameterEntryForParameterDefaultTypeAlignWithType(
421 Map.Entry<String, Parameter> parameterEntry,
422 String fileName, GlobalValidationContext globalContext){
423 Parameter parameter = parameterEntry.getValue();
424 String parameterType = parameter.getType();
425 Object parameterDefault = parameter.get_default();
426 if (parameterDefault != null && parameterType != null) {
427 boolean isValueMatchDefault =
428 DefinedHeatParameterTypes.isValueIsFromGivenType(parameterDefault,
430 if (!isValueMatchDefault) {
431 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
432 .getErrorWithParameters(
433 ERROR_CODE_HOT_4,Messages
434 .PARAMETER_DEFAULT_VALUE_NOT_ALIGN_WITH_TYPE.getErrorMessage(),
435 parameterEntry.getKey(), parameterType));
440 private static void validateEnvParametersMatchDefinedHeatParameterTypes(String envFile,
441 Environment envContent,
442 GlobalValidationContext globalContext,
443 HeatOrchestrationTemplate heatOrchestrationTemplate) {
444 Map<String, Parameter> heatParameters = heatOrchestrationTemplate.getParameters();
446 if (MapUtils.isNotEmpty(heatParameters) && MapUtils.isNotEmpty(envContent.getParameters())) {
447 validateEnvEntryForEnvParametersMatchDefinedHeatParameterTypes(envContent,
448 heatParameters, envFile, globalContext);
454 private static void validateEnvEntryForEnvParametersMatchDefinedHeatParameterTypes(
455 Environment envContent,
456 Map<String, Parameter> heatParameters,
458 GlobalValidationContext globalContext) {
459 for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
460 String parameterName = envEntry.getKey();
461 Object parameterEnvValue = envEntry.getValue();
462 Parameter parameterFromHeatFile = heatParameters.get(parameterName);
463 if (parameterFromHeatFile != null) {
464 String parameterType = parameterFromHeatFile.getType();
465 if (!DefinedHeatParameterTypes.isEmptyValueInEnv(parameterEnvValue)
466 && !DefinedHeatParameterTypes
467 .isValueIsFromGivenType(parameterEnvValue, parameterType)) {
468 globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
469 .getErrorWithParameters(
470 ERROR_CODE_HOT_5,Messages
471 .PARAMETER_ENV_VALUE_NOT_ALIGN_WITH_TYPE.getErrorMessage(),
479 public void validate(GlobalValidationContext globalContext) {
480 ManifestContent manifestContent;
482 manifestContent = ValidationUtil.validateManifest(globalContext);
483 } catch (Exception exception) {
484 LOGGER.error("Failed to validate manifest file", exception);
487 Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
488 Map<String, FileData> fileEnvMap = ManifestUtil.getFileAndItsEnv(manifestContent);
489 Set<String> artifacts = new HashSet<>();
491 globalContext.getFiles().stream()
492 .filter(fileName -> FileData.isHeatFile(fileTypeMap.get(fileName))).forEach(
493 fileName -> validate(fileName, fileEnvMap.get(fileName) == null ? null : fileEnvMap.get(
494 fileName).getFile(), artifacts,
498 Set<String> manifestArtifacts = ManifestUtil.getArtifacts(manifestContent);
500 globalContext.getFiles().stream()
501 .filter(fileName -> isManifestArtifact(manifestArtifacts, fileName)
502 && isNotArtifact(artifacts, fileName))
503 .forEach(fileName -> globalContext.addMessage(fileName, ErrorLevel.WARNING,
504 ErrorMessagesFormatBuilder
505 .getErrorWithParameters(ERROR_CODE_HOT_11,
506 Messages.ARTIFACT_FILE_NOT_REFERENCED.getErrorMessage())));
509 private boolean isManifestArtifact(Set<String> manifestArtifacts, String fileName) {
510 return manifestArtifacts.contains(fileName);
513 private boolean isNotArtifact(Set<String> artifacts, String fileName) {
514 return !artifacts.contains(fileName);
517 private void validate(String fileName, String envFileName,
518 Set<String> artifacts,
519 GlobalValidationContext globalContext) {
520 globalContext.setMessageCode(ERROR_CODE_HOT_12);
521 HeatOrchestrationTemplate
522 heatOrchestrationTemplate = ValidationUtil.checkHeatOrchestrationPreCondition(
523 fileName, globalContext);
526 if (heatOrchestrationTemplate != null) {
527 if (!(fileName.contains(".yaml") || fileName.contains(".yml"))) {
528 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
529 .getErrorWithParameters(ERROR_CODE_HOT_6,Messages
530 .WRONG_HEAT_FILE_EXTENSION.getErrorMessage(), fileName));
533 validateHeatBaseStructure(fileName, heatOrchestrationTemplate, globalContext);
534 validateParameterDefaultTypeAlignWithType(fileName, heatOrchestrationTemplate, globalContext);
535 validateAllResourceReferencesExist(fileName, heatOrchestrationTemplate, globalContext);
536 validateResourceDependsOn(fileName, heatOrchestrationTemplate, globalContext);
537 validateGetParamPointToParameter(fileName, heatOrchestrationTemplate, globalContext);
538 validateGetAttr(fileName, heatOrchestrationTemplate, globalContext);
539 validateAllRequiredArtifactsExist(fileName, heatOrchestrationTemplate, artifacts,
542 if (envFileName != null) {
543 validateEnvFile(fileName, envFileName, heatOrchestrationTemplate, globalContext);
548 private void validateResourceDependsOn(String fileName,
549 HeatOrchestrationTemplate heatOrchestrationTemplate,
550 GlobalValidationContext globalContext) {
551 Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
552 if(MapUtils.isEmpty(resourcesMap)) {
556 Set<String> resourcesNames = resourcesMap.keySet();
558 resourcesMap.entrySet().stream()
559 .forEach(entry -> checkResourceDependsOn(fileName, entry.getValue(),
560 resourcesNames, globalContext));
563 @SuppressWarnings("unchecked")
564 private static void checkResourceDependsOn(String fileName, Resource resource,
565 Set<String> resourcesNames,
566 GlobalValidationContext globalContext) {
567 Object dependencies = resource.getDepends_on();
568 if (dependencies instanceof Collection) {
569 ((Collection<String>) dependencies)
571 .filter(resourceId -> !resourcesNames.contains(resourceId))
572 .forEach(resourceId -> globalContext.addMessage(fileName, ErrorLevel.ERROR,
573 ErrorMessagesFormatBuilder
574 .getErrorWithParameters(ERROR_CODE_HOT_7,
575 Messages.MISSING_RESOURCE_IN_DEPENDS_ON.getErrorMessage(), resourceId)));
576 } else if (dependencies instanceof String && !resourcesNames.contains(dependencies)) {
577 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
578 .getErrorWithParameters(ERROR_CODE_HOT_8,
579 Messages.MISSING_RESOURCE_IN_DEPENDS_ON.getErrorMessage(), String.valueOf(dependencies)));
584 private void validateHeatBaseStructure(String fileName,
585 HeatOrchestrationTemplate heatOrchestrationTemplate,
586 GlobalValidationContext globalContext) {
587 if (heatOrchestrationTemplate.getHeat_template_version() == null) {
588 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
589 .getErrorWithParameters(ERROR_CODE_HOT_9,
590 Messages.INVALID_HEAT_FORMAT_REASON.getErrorMessage(),
591 "missing template version"));
593 if (heatOrchestrationTemplate.getResources() == null
594 || heatOrchestrationTemplate.getResources().size() == 0) {
595 globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
596 .getErrorWithParameters(ERROR_CODE_HOT_10,
597 Messages.INVALID_HEAT_FORMAT_REASON.getErrorMessage(),
598 "The heat file does not contain any resources"));
603 @SuppressWarnings("unchecked")
604 private void getSecurityGroupsReferencedResourcesFromOutputs(
605 Set<String> securityGroupsNamesFromOutputsMap, Map<String, Output> outputMap,
606 Map<String, Resource> resourceMap) {
607 if (MapUtils.isNotEmpty(outputMap)) {
608 for (Map.Entry<String, Output> outputEntry : outputMap.entrySet()) {
610 validateOutputEntryForGetSecurityGroupsReferencedResourcesFromOutputs(outputEntry,
611 resourceMap, securityGroupsNamesFromOutputsMap);
616 private void validateOutputEntryForGetSecurityGroupsReferencedResourcesFromOutputs(
617 Map.Entry<String, Output> outputEntry,
618 Map<String, Resource> resourceMap, Set<String> securityGroupsNamesFromOutputsMap){
619 Object outputValue = outputEntry.getValue().getValue();
620 if (Objects.nonNull(outputValue) && outputValue instanceof Map) {
621 String resourceName = (String) ((Map) outputValue)
622 .get(ResourceReferenceFunctions.GET_RESOURCE.getFunction());
623 if (Objects.nonNull(resourceName)) {
624 Resource resource = resourceMap.get(resourceName);
625 if (Objects.nonNull(resource) && resource.getType().equals(
626 HeatResourcesTypes.NEUTRON_SECURITY_GROUP_RESOURCE_TYPE.getHeatResource())) {
627 securityGroupsNamesFromOutputsMap.add(outputEntry.getKey());