gerrit.onap Code Review - sdc.git/blob

   1 /*
   2  * Copyright © 2016-2017 European Support Limited
   3  *
   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
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  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.
  15  */
  16 package org.openecomp.sdc.validation.impl.validators;
  17
  18 import java.io.InputStream;
  19 import java.util.Collection;
  20 import java.util.HashSet;
  21 import java.util.List;
  22 import java.util.Map;
  23 import java.util.Objects;
  24 import java.util.Optional;
  25 import java.util.Set;
  26 import org.apache.commons.collections4.CollectionUtils;
  27 import org.apache.commons.collections4.MapUtils;
  28 import org.onap.sdc.tosca.services.YamlUtil;
  29 import org.openecomp.core.validation.ErrorMessageCode;
  30 import org.openecomp.core.validation.errors.ErrorMessagesFormatBuilder;
  31 import org.openecomp.core.validation.types.GlobalValidationContext;
  32 import org.openecomp.sdc.common.errors.Messages;
  33 import org.openecomp.sdc.datatypes.error.ErrorLevel;
  34 import org.openecomp.sdc.heat.datatypes.DefinedHeatParameterTypes;
  35 import org.openecomp.sdc.heat.datatypes.manifest.FileData;
  36 import org.openecomp.sdc.heat.datatypes.manifest.ManifestContent;
  37 import org.openecomp.sdc.heat.datatypes.model.Environment;
  38 import org.openecomp.sdc.heat.datatypes.model.HeatOrchestrationTemplate;
  39 import org.openecomp.sdc.heat.datatypes.model.HeatPseudoParameters;
  40 import org.openecomp.sdc.heat.datatypes.model.Output;
  41 import org.openecomp.sdc.heat.datatypes.model.Parameter;
  42 import org.openecomp.sdc.heat.datatypes.model.Resource;
  43 import org.openecomp.sdc.heat.datatypes.model.ResourceReferenceFunctions;
  44 import org.openecomp.sdc.heat.services.HeatStructureUtil;
  45 import org.openecomp.sdc.heat.services.manifest.ManifestUtil;
  46 import org.openecomp.sdc.logging.api.Logger;
  47 import org.openecomp.sdc.logging.api.LoggerFactory;
  48 import org.openecomp.sdc.validation.Validator;
  49 import org.openecomp.sdc.validation.impl.util.HeatValidationService;
  50 import org.openecomp.sdc.validation.util.ValidationUtil;
  51
  52 public class HeatValidator implements Validator {
  53
  54     // The Artifacts generated by SDC - not allowed to be in HEAT
  55     static final String VF_LICENSE_MODEL_XML = "vf-license-model.xml";
  56     static final String VENDOR_LICENSE_MODEL_XML = "vendor-license-model.xml";
  57     static final String HEAT_META = "HEAT.meta";
  58     private static final Logger LOGGER = LoggerFactory.getLogger(HeatValidator.class);
  59     private static final ErrorMessageCode ERROR_CODE_HOT_1 = new ErrorMessageCode("HOT1");
  60     private static final ErrorMessageCode ERROR_CODE_HOT_2 = new ErrorMessageCode("HOT2");
  61     private static final ErrorMessageCode ERROR_CODE_HOT_3 = new ErrorMessageCode("HOT3");
  62     private static final ErrorMessageCode ERROR_CODE_HOT_4 = new ErrorMessageCode("HOT4");
  63     private static final ErrorMessageCode ERROR_CODE_HOT_5 = new ErrorMessageCode("HOT5");
  64     private static final ErrorMessageCode ERROR_CODE_HOT_6 = new ErrorMessageCode("HOT6");
  65     private static final ErrorMessageCode ERROR_CODE_HOT_7 = new ErrorMessageCode("HOT7");
  66     private static final ErrorMessageCode ERROR_CODE_HOT_8 = new ErrorMessageCode("HOT8");
  67     private static final ErrorMessageCode ERROR_CODE_HOT_9 = new ErrorMessageCode("HOT9");
  68     private static final ErrorMessageCode ERROR_CODE_HOT_10 = new ErrorMessageCode("HOT10");
  69     private static final ErrorMessageCode ERROR_CODE_HOT_11 = new ErrorMessageCode("HOT11");
  70     private static final ErrorMessageCode ERROR_CODE_HOT_12 = new ErrorMessageCode("HOT12");
  71     private static final ErrorMessageCode ERROR_CODE_HOT_13 = new ErrorMessageCode("HOT13");
  72     private static final ErrorMessageCode ERROR_CODE_HOT_14 = new ErrorMessageCode("HOT14");
  73     private static final ErrorMessageCode ERROR_CODE_HOT_15 = new ErrorMessageCode("HOT15");
  74     private static final ErrorMessageCode ERROR_CODE_HOT_16 = new ErrorMessageCode("HOT16");
  75     private static final ErrorMessageCode ERROR_CODE_HOT_17 = new ErrorMessageCode("HOT17");
  76     private static final ErrorMessageCode ERROR_CODE_HOT_18 = new ErrorMessageCode("HOT18");
  77     private static final Set<String> GENERATED_ARTIFACTS;
  78
  79     static {
  80         GENERATED_ARTIFACTS = getGeneratedArtifactNames();
  81     }
  82
  83     private static void validateAllRequiredArtifactsExist(String fileName, HeatOrchestrationTemplate heatOrchestrationTemplate, Set<String> artifacts,
  84                                                           GlobalValidationContext globalContext) {
  85         Collection<Resource> resourcesValues =
  86             heatOrchestrationTemplate.getResources() == null ? null : heatOrchestrationTemplate.getResources().values();
  87         if (CollectionUtils.isNotEmpty(resourcesValues)) {
  88             for (Resource resource : resourcesValues) {
  89                 Collection<Object> properties = resource.getProperties() == null ? null : resource.getProperties().values();
  90                 validatePropertiesForAllRequiredArtifactsExist(properties, fileName, artifacts, globalContext);
  91             }
  92         }
  93     }
  94
  95     private static void validatePropertiesForAllRequiredArtifactsExist(Collection<Object> properties, String fileName, 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, ResourceReferenceFunctions.GET_FILE.getFunction(), property, globalContext);
 103                     artifacts.addAll(artifactNames);
 104                     globalContext.setMessageCode(ERROR_CODE_HOT_15);
 105                     HeatValidationService.checkArtifactsExistence(fileName, artifactNames, globalContext);
 106                 }
 107             }
 108         }
 109     }
 110     /* validation 14 */
 111
 112     private static void validateAllResourceReferencesExist(String fileName,
 113                                                            HeatOrchestrationTemplate
 114                                                                heatOrchestrationTemplate,
 115                                                            GlobalValidationContext globalContext) {
 116         Set<String> resourcesNames = heatOrchestrationTemplate.getResources() == null ? null
 117             : heatOrchestrationTemplate.getResources().keySet();
 118         Collection<Resource> resourcesValues = heatOrchestrationTemplate.getResources() == null ? null
 119             : heatOrchestrationTemplate.getResources().values();
 120         Collection<Output> outputsValues = heatOrchestrationTemplate.getOutputs() == null ? null
 121             : heatOrchestrationTemplate.getOutputs().values();
 122         checkResourceExistenceFromResourcesMap(fileName, resourcesNames, resourcesValues,
 123             globalContext);
 124         checkResourceExistenceFromResourcesMap(fileName, resourcesNames, outputsValues,
 125             globalContext);
 126     }
 127
 128     private static void checkResourceExistenceFromResourcesMap(String fileName,
 129                                                                Set<String> resourcesNames,
 130                                                                Collection<?> valuesToSearchIn,
 131                                                                GlobalValidationContext globalContext) {
 132         if (CollectionUtils.isNotEmpty(valuesToSearchIn)) {
 133             for (Object value : valuesToSearchIn) {
 134                 if (value instanceof Resource) {
 135                     extractResourceProperty(fileName, resourcesNames, globalContext,
 136                         (Resource) value);
 137                 } else if (value instanceof Output) {
 138                     Output output = (Output) value;
 139                     Object outputsValue = output.getValue();
 140                     handleReferencedResources(fileName, outputsValue, resourcesNames,
 141                         globalContext);
 142                 }
 143             }
 144         }
 145     }
 146
 147     private static void extractResourceProperty(String fileName, Set<String> resourcesNames,
 148                                                 GlobalValidationContext globalContext,
 149                                                 Resource value) {
 150         Collection<Object> resourcePropertiesValues =
 151             value.getProperties() == null ? null : value.getProperties()
 152                 .values();
 153         if (CollectionUtils.isNotEmpty(resourcePropertiesValues)) {
 154             for (Object propertyValue : resourcePropertiesValues) {
 155                 handleReferencedResources(fileName, propertyValue, resourcesNames,
 156                     globalContext);
 157             }
 158         }
 159     }
 160
 161     private static void handleReferencedResources(String fileName, Object valueToSearchReferencesIn,
 162                                                   Set<String> resourcesNames,
 163                                                   GlobalValidationContext globalContext) {
 164         globalContext.setMessageCode(ERROR_CODE_HOT_13);
 165         Set<String> referencedResourcesNames = HeatStructureUtil
 166             .getReferencedValuesByFunctionName(fileName,
 167                 ResourceReferenceFunctions.GET_RESOURCE.getFunction(),
 168                 valueToSearchReferencesIn, globalContext);
 169         if (CollectionUtils.isNotEmpty(referencedResourcesNames)) {
 170             checkIfResourceReferenceExist(fileName, resourcesNames, referencedResourcesNames,
 171                 globalContext);
 172         }
 173     }
 174
 175     private static void checkIfResourceReferenceExist(String fileName,
 176                                                       Set<String> referencedResourcesNames,
 177                                                       Set<String> referencedResources,
 178                                                       GlobalValidationContext globalContext) {
 179         referencedResources.stream()
 180             .filter(referencedResource -> !referencedResourcesNames
 181                 .contains(referencedResource))
 182             .forEach(referencedResource ->
 183                 globalContext.addMessage(fileName,
 184                     ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 185                         .getErrorWithParameters(ERROR_CODE_HOT_16, Messages
 186                             .REFERENCED_RESOURCE_NOT_FOUND.getErrorMessage(), referencedResource)));
 187     }
 188
 189     /* validation 16 */
 190     private static void validateGetParamPointToParameter(String fileName, HeatOrchestrationTemplate heatOrchestrationTemplate,
 191                                                          GlobalValidationContext globalContext) {
 192         Set<String> parametersNames = heatOrchestrationTemplate.getParameters() == null ? null : heatOrchestrationTemplate.getParameters().keySet();
 193         Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
 194         if (CollectionUtils.isNotEmpty(parametersNames) && MapUtils.isNotEmpty(resourcesMap)) {
 195             for (Map.Entry<String, Resource> resourceEntry : resourcesMap.entrySet()) {
 196                 Resource resource = resourceEntry.getValue();
 197                 Map<String, Object> properties = resource.getProperties();
 198                 validatePropertiesForGetParamPointToParameter(properties, fileName, parametersNames, resourceEntry, globalContext);
 199             }
 200         }
 201     }
 202
 203     private static void validatePropertiesForGetParamPointToParameter(Map<String, Object> properties, String fileName, Set<String> parametersNames,
 204                                                                       Map.Entry<String, Resource> resourceEntry,
 205                                                                       GlobalValidationContext globalContext) {
 206         if (MapUtils.isNotEmpty(properties)) {
 207             Collection<Object> propertiesValues = properties.values();
 208             if (CollectionUtils.isNotEmpty(propertiesValues)) {
 209                 for (Object propertyObject : propertiesValues) {
 210                     Set<String> referencedParameterNames = HeatStructureUtil
 211                         .getReferencedValuesByFunctionName(fileName, "get_param", propertyObject, globalContext);
 212                     validateReferenceParams(fileName, resourceEntry.getKey(), parametersNames, referencedParameterNames, globalContext);
 213                 }
 214             }
 215         }
 216     }
 217
 218     private static void validateReferenceParams(String fileName, String resourceName, Set<String> parametersNamesFromFile,
 219                                                 Set<String> referencedParametersNames, GlobalValidationContext globalContext) {
 220         for (String parameterName : referencedParametersNames) {
 221             if (!isHeatPseudoParameter(parameterName) && !parametersNamesFromFile.contains(parameterName)) {
 222                 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 223                     .getErrorWithParameters(ERROR_CODE_HOT_1, Messages.REFERENCED_PARAMETER_NOT_FOUND.getErrorMessage(), parameterName,
 224                         resourceName));
 225             }
 226         }
 227     }
 228
 229     private static boolean isHeatPseudoParameter(String parameterName) {
 230         return HeatPseudoParameters.getPseudoParameterNames().contains(parameterName);
 231     }
 232     /* validation 18*/
 233
 234     private static void validateGetAttr(String fileName,
 235                                         HeatOrchestrationTemplate heatOrchestrationTemplate,
 236                                         GlobalValidationContext globalContext) {
 237         Map<String, Output> outputMap;
 238         outputMap = heatOrchestrationTemplate.getOutputs();
 239
 240         if (MapUtils.isNotEmpty(outputMap)) {
 241             loopOverOutputMapAndValidateGetAttrFromNested(fileName, outputMap,
 242                 heatOrchestrationTemplate, globalContext);
 243         }
 244     }
 245
 246     private static void loopOverOutputMapAndValidateGetAttrFromNested(String fileName,
 247                                                                       Map<String, Output> outputMap,
 248                                                                       HeatOrchestrationTemplate
 249                                                                           heatOrchestrationTemplate,
 250                                                                       GlobalValidationContext
 251                                                                           globalContext) {
 252         for (Output output : outputMap.values()) {
 253             Object outputValue = output.getValue();
 254             if (outputValue instanceof Map) {
 255                 Map<String, Object> outputValueMap = (Map<String, Object>) outputValue;
 256                 List<String> getAttrValue =
 257                     (List<String>) outputValueMap.get(
 258                         ResourceReferenceFunctions.GET_ATTR.getFunction());
 259                 handleGetAttrValueList(getAttrValue, fileName, heatOrchestrationTemplate,
 260                     globalContext);
 261
 262             }
 263         }
 264     }
 265
 266     private static void handleGetAttrValueList(List<String> getAttrValue, String fileName,
 267                                                HeatOrchestrationTemplate heatOrchestrationTemplate,
 268                                                GlobalValidationContext globalContext) {
 269         if (!CollectionUtils.isEmpty(getAttrValue)) {
 270             String resourceName = getAttrValue.get(0);
 271             String attNameObject = getAttrValue.get(1);
 272             if (attNameObject == null) {
 273                 return;
 274             }
 275             String attName = getAttrValue.get(1);
 276             String resourceType =
 277                 getResourceTypeFromResourcesMap(resourceName, heatOrchestrationTemplate);
 278
 279             if (Objects.nonNull(resourceType)
 280                 && HeatValidationService.isNestedResource(resourceType)) {
 281                 handleGetAttrNestedResource(fileName, globalContext, resourceName, attName,
 282                     resourceType);
 283             }
 284         }
 285     }
 286
 287     private static void handleGetAttrNestedResource(String fileName,
 288                                                     GlobalValidationContext globalContext,
 289                                                     String resourceName, String attName,
 290                                                     String resourceType) {
 291         Map<String, Output> nestedOutputMap;
 292         HeatOrchestrationTemplate nestedHeatOrchestrationTemplate;
 293         try {
 294             Optional<InputStream> fileContent = globalContext.getFileContent(resourceType);
 295             if (fileContent.isPresent()) {
 296                 nestedHeatOrchestrationTemplate =
 297                     new YamlUtil().yamlToObject(fileContent.get(), HeatOrchestrationTemplate.class);
 298             } else {
 299                 throw new Exception("The file '" + resourceType + "' has no content");
 300             }
 301         } catch (Exception exception) {
 302             LOGGER.error("Invalid yaml file", exception);
 303             return;
 304         }
 305         nestedOutputMap = nestedHeatOrchestrationTemplate.getOutputs();
 306
 307         if (MapUtils.isEmpty(nestedOutputMap) || !nestedOutputMap.containsKey(attName)) {
 308             globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 309                 .getErrorWithParameters(ERROR_CODE_HOT_17, Messages
 310                         .GET_ATTR_NOT_FOUND.getErrorMessage(),
 311                     attName, resourceName));
 312         }
 313     }
 314
 315     private static String getResourceTypeFromResourcesMap(String resourceName,
 316                                                           HeatOrchestrationTemplate
 317                                                               heatOrchestrationTemplate) {
 318         Resource resource = heatOrchestrationTemplate.getResources().get(resourceName);
 319         if (Objects.nonNull(resource)) {
 320             return resource.getType();
 321         } else {
 322             return null;
 323         }
 324     }
 325
 326     /* validation 17 + */
 327     private static void validateEnvFile(String fileName, String envFileName, HeatOrchestrationTemplate heatOrchestrationTemplate,
 328                                         GlobalValidationContext globalContext) {
 329         Environment envContent;
 330         if (!envFileName.contains(".env")) {
 331             globalContext.addMessage(envFileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 332                 .getErrorWithParameters(ERROR_CODE_HOT_2, Messages.WRONG_ENV_FILE_EXTENSION.getErrorMessage(), envFileName));
 333         }
 334         envContent = HeatValidationService.validateEnvContent(fileName, envFileName, globalContext);
 335         if (envContent != null) {
 336             validateEnvContentIsSubSetOfHeatParameters(envFileName, envContent, globalContext, heatOrchestrationTemplate);
 337             validateEnvParametersMatchDefinedHeatParameterTypes(envFileName, envContent, globalContext, heatOrchestrationTemplate);
 338         }
 339     }
 340
 341     private static void validateEnvContentIsSubSetOfHeatParameters(String envFile, Environment envContent, GlobalValidationContext globalContext,
 342                                                                    HeatOrchestrationTemplate heatOrchestrationTemplate) {
 343         Set<String> parametersNames = heatOrchestrationTemplate.getParameters() == null ? null : heatOrchestrationTemplate.getParameters().keySet();
 344         if (MapUtils.isNotEmpty(envContent.getParameters())) {
 345             if (CollectionUtils.isNotEmpty(parametersNames)) {
 346                 for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
 347                     validateEnvEntryForvalidateEnvContentIsSubSetOfHeatParameters(envEntry, parametersNames, envFile, globalContext);
 348                 }
 349             } else {
 350                 for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
 351                     globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 352                         .getErrorWithParameters(ERROR_CODE_HOT_3, Messages.ENV_INCLUDES_PARAMETER_NOT_IN_HEAT.getErrorMessage(), envFile,
 353                             envEntry.getKey()));
 354                 }
 355             }
 356         }
 357     }
 358
 359     private static void validateEnvEntryForvalidateEnvContentIsSubSetOfHeatParameters(Map.Entry<String, Object> envEntry, Set<String> parametersNames,
 360                                                                                       String envFile, GlobalValidationContext globalContext) {
 361         String envParameter = envEntry.getKey();
 362         if (parametersNames != null && !parametersNames.contains(envParameter)) {
 363             globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 364                 .getErrorWithParameters(ERROR_CODE_HOT_3, Messages.ENV_INCLUDES_PARAMETER_NOT_IN_HEAT.getErrorMessage(), envFile, envParameter));
 365         }
 366     }
 367
 368     private static void validateParameterDefaultTypeAlignWithType(String fileName, HeatOrchestrationTemplate heatOrchestrationTemplate,
 369                                                                   GlobalValidationContext globalContext) {
 370         Map<String, Parameter> parametersMap = heatOrchestrationTemplate.getParameters();
 371         if (MapUtils.isNotEmpty(parametersMap)) {
 372             for (Map.Entry<String, Parameter> parameterEntry : parametersMap.entrySet()) {
 373                 validateParameterEntryForParameterDefaultTypeAlignWithType(parameterEntry, fileName, globalContext);
 374             }
 375         }
 376     }
 377
 378     private static void validateParameterEntryForParameterDefaultTypeAlignWithType(Map.Entry<String, Parameter> parameterEntry, String fileName,
 379                                                                                    GlobalValidationContext globalContext) {
 380         Parameter parameter = parameterEntry.getValue();
 381         String parameterType = parameter.getType();
 382         Object parameterDefault = parameter.get_default();
 383         if (parameterDefault != null && parameterType != null) {
 384             boolean isValueMatchDefault = DefinedHeatParameterTypes.isValueIsFromGivenType(parameterDefault, parameterType);
 385             if (!isValueMatchDefault) {
 386                 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 387                     .getErrorWithParameters(ERROR_CODE_HOT_4, Messages.PARAMETER_DEFAULT_VALUE_NOT_ALIGN_WITH_TYPE.getErrorMessage(),
 388                         parameterEntry.getKey(), parameterType));
 389             }
 390         }
 391     }
 392
 393     private static void validateEnvParametersMatchDefinedHeatParameterTypes(String envFile, Environment envContent,
 394                                                                             GlobalValidationContext globalContext,
 395                                                                             HeatOrchestrationTemplate heatOrchestrationTemplate) {
 396         Map<String, Parameter> heatParameters = heatOrchestrationTemplate.getParameters();
 397         if (MapUtils.isNotEmpty(heatParameters) && MapUtils.isNotEmpty(envContent.getParameters())) {
 398             validateEnvEntryForEnvParametersMatchDefinedHeatParameterTypes(envContent, heatParameters, envFile, globalContext);
 399         }
 400     }
 401
 402     private static void validateEnvEntryForEnvParametersMatchDefinedHeatParameterTypes(Environment envContent, Map<String, Parameter> heatParameters,
 403                                                                                        String envFile, GlobalValidationContext globalContext) {
 404         for (Map.Entry<String, Object> envEntry : envContent.getParameters().entrySet()) {
 405             String parameterName = envEntry.getKey();
 406             Object parameterEnvValue = envEntry.getValue();
 407             Parameter parameterFromHeatFile = heatParameters.get(parameterName);
 408             if (parameterFromHeatFile != null) {
 409                 String parameterType = parameterFromHeatFile.getType();
 410                 if (!DefinedHeatParameterTypes.isEmptyValueInEnv(parameterEnvValue) && !DefinedHeatParameterTypes
 411                     .isValueIsFromGivenType(parameterEnvValue, parameterType)) {
 412                     globalContext.addMessage(envFile, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 413                         .getErrorWithParameters(ERROR_CODE_HOT_5, Messages.PARAMETER_ENV_VALUE_NOT_ALIGN_WITH_TYPE.getErrorMessage(), parameterName));
 414                 }
 415             }
 416         }
 417     }
 418
 419     private static Set<String> getGeneratedArtifactNames() {
 420         Set<String> predefinedArtifactNames = new HashSet<>();
 421         predefinedArtifactNames.add(VF_LICENSE_MODEL_XML);
 422         predefinedArtifactNames.add(VENDOR_LICENSE_MODEL_XML);
 423         predefinedArtifactNames.add(HEAT_META);
 424         return predefinedArtifactNames;
 425     }
 426
 427     @SuppressWarnings("unchecked")
 428     private static void checkResourceDependsOn(String fileName, Resource resource, Set<String> resourcesNames,
 429                                                GlobalValidationContext globalContext) {
 430         Object dependencies = resource.getDepends_on();
 431         if (dependencies instanceof Collection) {
 432             ((Collection<String>) dependencies).stream().filter(resourceId -> !resourcesNames.contains(resourceId)).forEach(
 433                 resourceId -> globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 434                     .getErrorWithParameters(ERROR_CODE_HOT_7, Messages.MISSING_RESOURCE_IN_DEPENDS_ON.getErrorMessage(), resourceId)));
 435         } else if (dependencies instanceof String && !resourcesNames.contains(dependencies)) {
 436             globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 437                 .getErrorWithParameters(ERROR_CODE_HOT_8, Messages.MISSING_RESOURCE_IN_DEPENDS_ON.getErrorMessage(), String.valueOf(dependencies)));
 438         }
 439     }
 440
 441     @Override
 442     public void validate(GlobalValidationContext globalContext) {
 443         ManifestContent manifestContent;
 444         try {
 445             manifestContent = ValidationUtil.validateManifest(globalContext);
 446         } catch (Exception exception) {
 447             LOGGER.error("Failed to validate manifest file", exception);
 448             return;
 449         }
 450         Map<String, FileData.Type> fileTypeMap = ManifestUtil.getFileTypeMap(manifestContent);
 451         Map<String, FileData> fileEnvMap = ManifestUtil.getFileAndItsEnv(manifestContent);
 452         Set<String> artifacts = new HashSet<>();
 453         globalContext.getFiles().stream().filter(fileName -> FileData.isHeatFile(fileTypeMap.get(fileName))).forEach(
 454             fileName -> validate(fileName, fileEnvMap.get(fileName) == null ? null : fileEnvMap.get(fileName).getFile(), artifacts, globalContext));
 455         Set<String> manifestArtifacts = ManifestUtil.getArtifacts(manifestContent);
 456         globalContext.getFiles().stream().filter(fileName -> isManifestArtifact(manifestArtifacts, fileName) && isNotArtifact(artifacts, fileName))
 457             .forEach(fileName -> {
 458                 globalContext.addMessage(fileName, ErrorLevel.WARNING,
 459                     ErrorMessagesFormatBuilder.getErrorWithParameters(ERROR_CODE_HOT_11, Messages.ARTIFACT_FILE_NOT_REFERENCED.getErrorMessage()));
 460                 validateGeneratedArtifact(fileName, globalContext);
 461             });
 462     }
 463
 464     private void validateGeneratedArtifact(String fileName, GlobalValidationContext globalContext) {
 465         if (GENERATED_ARTIFACTS.contains(fileName)) {
 466             globalContext.addMessage(fileName, ErrorLevel.ERROR,
 467                 ErrorMessagesFormatBuilder.getErrorWithParameters(ERROR_CODE_HOT_18, Messages.GENERATED_ARTIFACT_IN_USE.getErrorMessage(), fileName));
 468         }
 469     }
 470
 471     private boolean isManifestArtifact(Set<String> manifestArtifacts, String fileName) {
 472         return manifestArtifacts.contains(fileName);
 473     }
 474
 475     private boolean isNotArtifact(Set<String> artifacts, String fileName) {
 476         return !artifacts.contains(fileName);
 477     }
 478
 479     private void validate(String fileName, String envFileName, Set<String> artifacts, GlobalValidationContext globalContext) {
 480         globalContext.setMessageCode(ERROR_CODE_HOT_12);
 481         HeatOrchestrationTemplate heatOrchestrationTemplate = ValidationUtil.checkHeatOrchestrationPreCondition(fileName, globalContext);
 482         if (heatOrchestrationTemplate != null) {
 483             if (!(fileName.contains(".yaml") || fileName.contains(".yml"))) {
 484                 globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 485                     .getErrorWithParameters(ERROR_CODE_HOT_6, Messages.WRONG_HEAT_FILE_EXTENSION.getErrorMessage(), fileName));
 486             }
 487             validateHeatBaseStructure(fileName, heatOrchestrationTemplate, globalContext);
 488             validateParameterDefaultTypeAlignWithType(fileName, heatOrchestrationTemplate, globalContext);
 489             validateAllResourceReferencesExist(fileName, heatOrchestrationTemplate, globalContext);
 490             validateResourceDependsOn(fileName, heatOrchestrationTemplate, globalContext);
 491             validateGetParamPointToParameter(fileName, heatOrchestrationTemplate, globalContext);
 492             validateGetAttr(fileName, heatOrchestrationTemplate, globalContext);
 493             validateAllRequiredArtifactsExist(fileName, heatOrchestrationTemplate, artifacts, globalContext);
 494             if (envFileName != null) {
 495                 validateEnvFile(fileName, envFileName, heatOrchestrationTemplate, globalContext);
 496             }
 497         }
 498     }
 499
 500     private void validateResourceDependsOn(String fileName, HeatOrchestrationTemplate heatOrchestrationTemplate,
 501                                            GlobalValidationContext globalContext) {
 502         Map<String, Resource> resourcesMap = heatOrchestrationTemplate.getResources();
 503         if (MapUtils.isEmpty(resourcesMap)) {
 504             return;
 505         }
 506         Set<String> resourcesNames = resourcesMap.keySet();
 507         resourcesMap.entrySet().stream().forEach(entry -> checkResourceDependsOn(fileName, entry.getValue(), resourcesNames, globalContext));
 508     }
 509
 510     private void validateHeatBaseStructure(String fileName, HeatOrchestrationTemplate heatOrchestrationTemplate,
 511                                            GlobalValidationContext globalContext) {
 512         if (heatOrchestrationTemplate.getHeat_template_version() == null) {
 513             globalContext.addMessage(fileName, ErrorLevel.ERROR, ErrorMessagesFormatBuilder
 514                 .getErrorWithParameters(ERROR_CODE_HOT_9, Messages.INVALID_HEAT_FORMAT_REASON.getErrorMessage(), "missing template version"));
 515         }
 516         if (heatOrchestrationTemplate.getResources() == null || heatOrchestrationTemplate.getResources().size() == 0) {
 517             globalContext.addMessage(fileName, ErrorLevel.WARNING, ErrorMessagesFormatBuilder
 518                 .getErrorWithParameters(ERROR_CODE_HOT_10, Messages.INVALID_HEAT_FORMAT_REASON.getErrorMessage(),
 519                     "The heat file does not contain any resources"));
 520         }
 521     }
 522 }